kb01/zmk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(keymap): Add binding get/set, layer movement

Browse source 
* Add keymap API for getting/setting a bindings
  in keymap layers.
* Add layer move support via intemediary ordering array.
* Add settings storage for keymap changes.
This commit is contained in:
Peter Johanson 2024-04-10 20:48:33 +00:00 • committed by Pete Johanson
parent 0f972f1cc3
commit c8c19598a7
13 changed files with 1296 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
app/Kconfig
View file

@ -258,6 +258,26 @@ rsource "src/split/Kconfig"
#Basic Keyboard Setup
endmenu
menu "Keymaps"
config ZMK_KEYMAP_LAYER_REORDERING
bool "Layer Reordering Support"
config ZMK_KEYMAP_SETTINGS_STORAGE
bool "Settings Save/Load"
depends on SETTINGS
depends on ZMK_BEHAVIOR_LOCAL_IDS
if ZMK_KEYMAP_SETTINGS_STORAGE
config ZMK_KEYMAP_LAYER_NAME_MAX_LEN
int "Max Layer Name Length"
default 20
endif
endmenu # Keymaps
rsource "src/studio/Kconfig"
menu "Display/LED Options"

9
app/include/linker/zmk-rpc-subsystem-settings-reset.ld Normal file
View file

@ -0,0 +1,9 @@
/*
* Copyright (c) 2024 The ZMK Contributors
*
* SPDX-License-Identifier: MIT
*/
#include <zephyr/linker/linker-defs.h>
ITERABLE_SECTION_ROM(zmk_rpc_subsystem_settings_reset, 4)

62
app/include/zmk/keymap.h
View file

@ -12,17 +12,63 @@
#define ZMK_KEYMAP_LAYERS_LEN \
(DT_FOREACH_CHILD(DT_INST(0, zmk_keymap), ZMK_LAYER_CHILD_LEN_PLUS_ONE) 0)
/**
* @brief A layer ID is a stable identifier to refer to a layer, regardless of ordering.
*/
typedef uint8_t zmk_keymap_layer_id_t;
/**
* @brief A way to return/reference a missing or invalid layer ID
*/
#define ZMK_KEYMAP_LAYER_ID_INVAL UINT8_MAX
/**
* @brief A layer index is a identifier to refer layer at a particular position in the order.
*/
typedef uint8_t zmk_keymap_layer_index_t;
typedef uint32_t zmk_keymap_layers_state_t;
uint8_t zmk_keymap_layer_default(void);
zmk_keymap_layer_id_t zmk_keymap_layer_index_to_id(zmk_keymap_layer_index_t layer_index);
zmk_keymap_layer_id_t zmk_keymap_layer_default(void);
zmk_keymap_layers_state_t zmk_keymap_layer_state(void);
bool zmk_keymap_layer_active(uint8_t layer);
uint8_t zmk_keymap_highest_layer_active(void);
int zmk_keymap_layer_activate(uint8_t layer);
int zmk_keymap_layer_deactivate(uint8_t layer);
int zmk_keymap_layer_toggle(uint8_t layer);
int zmk_keymap_layer_to(uint8_t layer);
const char *zmk_keymap_layer_name(uint8_t layer);
bool zmk_keymap_layer_active(zmk_keymap_layer_id_t layer);
zmk_keymap_layer_id_t zmk_keymap_highest_layer_active(void);
int zmk_keymap_layer_activate(zmk_keymap_layer_id_t layer);
int zmk_keymap_layer_deactivate(zmk_keymap_layer_id_t layer);
int zmk_keymap_layer_toggle(zmk_keymap_layer_id_t layer);
int zmk_keymap_layer_to(zmk_keymap_layer_id_t layer);
const char *zmk_keymap_layer_name(zmk_keymap_layer_id_t layer);
const struct zmk_behavior_binding *zmk_keymap_get_layer_binding_at_idx(zmk_keymap_layer_id_t layer,
uint8_t binding_idx);
int zmk_keymap_set_layer_binding_at_idx(zmk_keymap_layer_id_t layer, uint8_t binding_idx,
const struct zmk_behavior_binding binding);
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
int zmk_keymap_add_layer(void);
int zmk_keymap_remove_layer(zmk_keymap_layer_index_t index);
int zmk_keymap_restore_layer(zmk_keymap_layer_id_t id, zmk_keymap_layer_index_t at_index);
int zmk_keymap_move_layer(zmk_keymap_layer_index_t start_idx, zmk_keymap_layer_index_t dest_idx);
int zmk_keymap_set_layer_name(zmk_keymap_layer_id_t id, const char *name, size_t size);
#endif
/**
* @brief Check if there are any unsaved keymap changes.
*
* @retval 0 if there are no changes.
* @retval 1 if there are changes.
*/
int zmk_keymap_check_unsaved_changes(void);
int zmk_keymap_save_changes(void);
int zmk_keymap_discard_changes(void);
int zmk_keymap_reset_settings(void);
int zmk_keymap_position_state_changed(uint8_t source, uint32_t position, bool pressed,
int64_t timestamp);

3
app/include/zmk/physical_layouts.h
View file

@ -40,4 +40,5 @@ int zmk_physical_layouts_check_unsaved_selection(void);
int zmk_physical_layouts_save_selected(void);
int zmk_physical_layouts_revert_selected(void);
int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, uint32_t *map);
int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, size_t map_size,
uint32_t map[map_size]);

14
app/include/zmk/studio/rpc.h
View file

@ -56,6 +56,12 @@ struct zmk_rpc_subsystem_handler {
enum zmk_studio_rpc_handler_security security;
};
typedef int (*zmk_rpc_subsystem_settings_reset_func)(void);
struct zmk_rpc_subsystem_settings_reset {
zmk_rpc_subsystem_settings_reset_func callback;
};
/**
* @brief Generate a "meta" subsystem response indicating an "empty" response to an RPC request.
*/
@ -103,6 +109,14 @@ struct zmk_rpc_subsystem_handler {
.security = _security, \
};
#define ZMK_RPC_SUBSYSTEM_SETTINGS_RESET(prefix, _callback) \
STRUCT_SECTION_ITERABLE(zmk_rpc_subsystem_settings_reset, _##prefix##_settings_reset) = { \
.callback = _callback, \
};
#define ZMK_RPC_SUBSYSTEM_SETTINGS_RESET_FOREACH(_var) \
STRUCT_SECTION_FOREACH(zmk_rpc_subsystem_settings_reset, _var)
/**
* @brief Create a zmk_studio_Notification struct for the given subsystem and type, including
initialization of the inner fields.

649
app/src/keymap.c
View file

@ -6,10 +6,12 @@
#include <drivers/behavior.h>
#include <zephyr/sys/util.h>
#include <zephyr/settings/settings.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/stdlib.h>
#include <zmk/behavior.h>
#include <zmk/keymap.h>
#include <zmk/matrix.h>
@ -27,7 +29,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/events/sensor_event.h>
static zmk_keymap_layers_state_t _zmk_keymap_layer_state = 0;
static uint8_t _zmk_keymap_layer_default = 0;
static zmk_keymap_layer_id_t _zmk_keymap_layer_default = 0;
#define DT_DRV_COMPAT zmk_keymap
@ -38,7 +40,11 @@ static uint8_t _zmk_keymap_layer_default = 0;
#endif
#define TRANSFORMED_LAYER(node) \
{ LISTIFY(DT_PROP_LEN(node, bindings), ZMK_KEYMAP_EXTRACT_BINDING, (, ), node) }
{ \
COND_CODE_1( \
DT_NODE_HAS_PROP(node, bindings), \
(LISTIFY(DT_PROP_LEN(node, bindings), ZMK_KEYMAP_EXTRACT_BINDING, (, ), node)), ()) \
}
#if ZMK_KEYMAP_HAS_SENSORS
#define _TRANSFORM_SENSOR_ENTRY(idx, layer) \
@ -58,7 +64,7 @@ static uint8_t _zmk_keymap_layer_default = 0;
#endif /* ZMK_KEYMAP_HAS_SENSORS */
#define LAYER_NAME(node) DT_PROP_OR(node, display_name, DT_PROP_OR(node, label, NULL))
#define LAYER_NAME(node) DT_PROP_OR(node, display_name, DT_PROP_OR(node, label, ""))
// State
@ -67,12 +73,36 @@ static uint8_t _zmk_keymap_layer_default = 0;
// still send the release event to the behavior in that layer also.
static uint32_t zmk_keymap_active_behavior_layer[ZMK_KEYMAP_LEN];
static struct zmk_behavior_binding zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_KEYMAP_LEN] = {
DT_INST_FOREACH_CHILD_SEP(0, TRANSFORMED_LAYER, (, ))};
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
static uint8_t keymap_layer_orders[ZMK_KEYMAP_LAYERS_LEN];
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
#define KEYMAP_VAR(_name, _opts) \
static _opts struct zmk_behavior_binding _name[ZMK_KEYMAP_LAYERS_LEN][ZMK_KEYMAP_LEN] = { \
COND_CODE_1(IS_ENABLED(CONFIG_ZMK_STUDIO), \
(DT_INST_FOREACH_CHILD_SEP(0, TRANSFORMED_LAYER, (, ))), \
(DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(0, TRANSFORMED_LAYER, (, ))))};
KEYMAP_VAR(zmk_keymap, )
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
KEYMAP_VAR(zmk_stock_keymap, const)
static char zmk_keymap_layer_names[ZMK_KEYMAP_LAYERS_LEN][CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN] = {
DT_INST_FOREACH_CHILD_SEP(0, LAYER_NAME, (, ))};
static uint32_t changed_layer_names = 0;
#else
static const char *zmk_keymap_layer_names[ZMK_KEYMAP_LAYERS_LEN] = {
DT_INST_FOREACH_CHILD_SEP(0, LAYER_NAME, (, ))};
#endif
#if ZMK_KEYMAP_HAS_SENSORS
static struct zmk_behavior_binding
@ -81,23 +111,50 @@ static struct zmk_behavior_binding
#endif /* ZMK_KEYMAP_HAS_SENSORS */
static inline int set_layer_state(uint8_t layer, bool state) {
#define ASSERT_LAYER_VAL(_layer, _fail_ret) \
if ((_layer) >= ZMK_KEYMAP_LAYERS_LEN) { \
return (_fail_ret); \
}
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
uint8_t map_layer_id_to_index(zmk_keymap_layer_id_t layer_id) {
for (uint8_t i = 0; i < ZMK_KEYMAP_LAYERS_LEN; i++) {
if (keymap_layer_orders[i] == layer_id) {
return i;
}
}
return ZMK_KEYMAP_LAYER_ID_INVAL;
}
#define LAYER_INDEX_TO_ID(_layer) keymap_layer_orders[_layer]
#define LAYER_ID_TO_INDEX(_layer) map_layer_id_to_index(_layer)
#else
#define LAYER_INDEX_TO_ID(_layer) _layer
#define LAYER_ID_TO_INDEX(_layer) _layer
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
static inline int set_layer_state(zmk_keymap_layer_id_t layer_id, bool state) {
int ret = 0;
if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
if (layer_id >= ZMK_KEYMAP_LAYERS_LEN) {
return -EINVAL;
}
// Default layer should *always* remain active
if (layer == _zmk_keymap_layer_default && !state) {
if (layer_id == _zmk_keymap_layer_default && !state) {
return 0;
}
zmk_keymap_layers_state_t old_state = _zmk_keymap_layer_state;
WRITE_BIT(_zmk_keymap_layer_state, layer, state);
WRITE_BIT(_zmk_keymap_layer_state, layer_id, state);
// Don't send state changes unless there was an actual change
if (old_state != _zmk_keymap_layer_state) {
LOG_DBG("layer_changed: layer %d state %d", layer, state);
ret = raise_layer_state_changed(layer, state);
LOG_DBG("layer_changed: layer %d state %d", layer_id, state);
ret = raise_layer_state_changed(layer_id, state);
if (ret < 0) {
LOG_WRN("Failed to raise layer state changed (%d)", ret);
}
@ -106,21 +163,28 @@ static inline int set_layer_state(uint8_t layer, bool state) {
return ret;
}
uint8_t zmk_keymap_layer_default(void) { return _zmk_keymap_layer_default; }
zmk_keymap_layer_id_t zmk_keymap_layer_index_to_id(zmk_keymap_layer_index_t layer_index) {
ASSERT_LAYER_VAL(layer_index, UINT8_MAX);
return LAYER_INDEX_TO_ID(layer_index);
}
zmk_keymap_layer_id_t zmk_keymap_layer_default(void) { return _zmk_keymap_layer_default; }
zmk_keymap_layers_state_t zmk_keymap_layer_state(void) { return _zmk_keymap_layer_state; }
bool zmk_keymap_layer_active_with_state(uint8_t layer, zmk_keymap_layers_state_t state_to_test) {
bool zmk_keymap_layer_active_with_state(zmk_keymap_layer_id_t layer,
zmk_keymap_layers_state_t state_to_test) {
// The default layer is assumed to be ALWAYS ACTIVE so we include an || here to ensure nobody
// breaks up that assumption by accident
return (state_to_test & (BIT(layer))) == (BIT(layer)) || layer == _zmk_keymap_layer_default;
};
bool zmk_keymap_layer_active(uint8_t layer) {
bool zmk_keymap_layer_active(zmk_keymap_layer_id_t layer) {
return zmk_keymap_layer_active_with_state(layer, _zmk_keymap_layer_state);
};
uint8_t zmk_keymap_highest_layer_active(void) {
zmk_keymap_layer_id_t zmk_keymap_highest_layer_active(void) {
for (uint8_t layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer > 0; layer--) {
if (zmk_keymap_layer_active(layer)) {
return layer;
@ -129,11 +193,13 @@ uint8_t zmk_keymap_highest_layer_active(void) {
return zmk_keymap_layer_default();
}
int zmk_keymap_layer_activate(uint8_t layer) { return set_layer_state(layer, true); };
int zmk_keymap_layer_activate(zmk_keymap_layer_id_t layer) { return set_layer_state(layer, true); };
int zmk_keymap_layer_deactivate(uint8_t layer) { return set_layer_state(layer, false); };
int zmk_keymap_layer_deactivate(zmk_keymap_layer_id_t layer) {
return set_layer_state(layer, false);
};
int zmk_keymap_layer_toggle(uint8_t layer) {
int zmk_keymap_layer_toggle(zmk_keymap_layer_id_t layer) {
if (zmk_keymap_layer_active(layer)) {
return zmk_keymap_layer_deactivate(layer);
}
@ -141,7 +207,7 @@ int zmk_keymap_layer_toggle(uint8_t layer) {
return zmk_keymap_layer_activate(layer);
};
int zmk_keymap_layer_to(uint8_t layer) {
int zmk_keymap_layer_to(zmk_keymap_layer_id_t layer) {
for (int i = ZMK_KEYMAP_LAYERS_LEN - 1; i >= 0; i--) {
zmk_keymap_layer_deactivate(i);
}
@ -151,18 +217,365 @@ int zmk_keymap_layer_to(uint8_t layer) {
return 0;
}
bool is_active_layer(uint8_t layer, zmk_keymap_layers_state_t layer_state) {
return (layer_state & BIT(layer)) == BIT(layer) || layer == _zmk_keymap_layer_default;
const char *zmk_keymap_layer_name(zmk_keymap_layer_id_t layer_id) {
ASSERT_LAYER_VAL(layer_id, NULL)
return zmk_keymap_layer_names[layer_id];
}
const char *zmk_keymap_layer_name(uint8_t layer) {
if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
const struct zmk_behavior_binding *
zmk_keymap_get_layer_binding_at_idx(zmk_keymap_layer_id_t layer_id, uint8_t binding_idx) {
if (binding_idx >= ZMK_KEYMAP_LEN) {
return NULL;
}
return zmk_keymap_layer_names[layer];
ASSERT_LAYER_VAL(layer_id, NULL)
return &zmk_keymap[layer_id][binding_idx];
}
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
#define PENDING_ARRAY_SIZE DIV_ROUND_UP(ZMK_KEYMAP_LEN, 8)
static uint8_t zmk_keymap_layer_pending_changes[ZMK_KEYMAP_LAYERS_LEN][PENDING_ARRAY_SIZE];
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
int zmk_keymap_set_layer_binding_at_idx(zmk_keymap_layer_id_t layer_id, uint8_t binding_idx,
struct zmk_behavior_binding binding) {
if (binding_idx >= ZMK_KEYMAP_LEN) {
return -EINVAL;
}
ASSERT_LAYER_VAL(layer_id, -EINVAL)
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
uint8_t *pending = zmk_keymap_layer_pending_changes[layer_id];
WRITE_BIT(pending[binding_idx / 8], binding_idx % 8, 1);
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
// TODO: Need a mutex to protect access to the keymap data?
memcpy(&zmk_keymap[layer_id][binding_idx], &binding, sizeof(binding));
return 0;
}
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
static uint8_t settings_layer_orders[ZMK_KEYMAP_LAYERS_LEN];
#endif
int zmk_keymap_move_layer(zmk_keymap_layer_index_t start_idx, zmk_keymap_layer_index_t dest_idx) {
ASSERT_LAYER_VAL(start_idx, -EINVAL)
ASSERT_LAYER_VAL(dest_idx, -EINVAL)
if (start_idx == dest_idx) {
return 0;
} else if (dest_idx > start_idx) {
uint8_t val = keymap_layer_orders[start_idx];
for (int i = start_idx; i < dest_idx; i++) {
keymap_layer_orders[i] = keymap_layer_orders[i + 1];
}
keymap_layer_orders[dest_idx] = val;
} else {
uint8_t val = keymap_layer_orders[start_idx];
for (int i = start_idx; i > dest_idx; i--) {
keymap_layer_orders[i] = keymap_layer_orders[i - 1];
}
keymap_layer_orders[dest_idx] = val;
}
return 0;
}
int zmk_keymap_add_layer(void) {
uint32_t seen_layer_ids = 0;
LOG_HEXDUMP_DBG(keymap_layer_orders, ZMK_KEYMAP_LAYERS_LEN, "Order");
for (int index = 0; index < ZMK_KEYMAP_LAYERS_LEN; index++) {
zmk_keymap_layer_id_t id = LAYER_INDEX_TO_ID(index);
if (id != ZMK_KEYMAP_LAYER_ID_INVAL) {
WRITE_BIT(seen_layer_ids, id, 1);
continue;
}
for (int candidate_id = 0; candidate_id < ZMK_KEYMAP_LAYERS_LEN; candidate_id++) {
if (!(seen_layer_ids & BIT(candidate_id))) {
keymap_layer_orders[index] = candidate_id;
return index;
}
}
}
return -ENOSPC;
}
int zmk_keymap_remove_layer(zmk_keymap_layer_index_t index) {
ASSERT_LAYER_VAL(index, -EINVAL);
if (keymap_layer_orders[index] == ZMK_KEYMAP_LAYER_ID_INVAL) {
return -EINVAL;
}
LOG_DBG("Removing layer index %d which is ID %d", index, keymap_layer_orders[index]);
LOG_HEXDUMP_DBG(keymap_layer_orders, ZMK_KEYMAP_LAYERS_LEN, "Order");
while (index < ZMK_KEYMAP_LAYERS_LEN - 1) {
keymap_layer_orders[index] = keymap_layer_orders[index + 1];
index++;
}
keymap_layer_orders[ZMK_KEYMAP_LAYERS_LEN - 1] = ZMK_KEYMAP_LAYER_ID_INVAL;
LOG_HEXDUMP_DBG(keymap_layer_orders, ZMK_KEYMAP_LAYERS_LEN, "Order");
return 0;
}
int zmk_keymap_restore_layer(zmk_keymap_layer_id_t id, zmk_keymap_layer_index_t at_index) {
ASSERT_LAYER_VAL(at_index, -EINVAL);
ASSERT_LAYER_VAL(id, -ENODEV);
for (zmk_keymap_layer_index_t index = ZMK_KEYMAP_LAYERS_LEN - 1; index > at_index; index--) {
keymap_layer_orders[index] = keymap_layer_orders[index - 1];
}
keymap_layer_orders[at_index] = id;
return 0;
}
int zmk_keymap_set_layer_name(zmk_keymap_layer_id_t id, const char *name, size_t size) {
ASSERT_LAYER_VAL(id, -EINVAL);
if (size >= CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN) {
return -ENOSPC;
}
strlcpy(zmk_keymap_layer_names[id], name, CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN);
// Ensure we properly null terminate our name if we previously had a longer one.
if (size < CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN - 1) {
zmk_keymap_layer_names[id][size] = 0;
}
WRITE_BIT(changed_layer_names, id, 1);
return 0;
}
#else
int zmk_keymap_move_layer(zmk_keymap_layer_index_t layer, zmk_keymap_layer_index_t dest) {
return -ENOTSUP;
}
int zmk_keymap_add_layer(void) { return -ENOTSUP; }
int zmk_keymap_remove_layer(zmk_keymap_layer_index_t index) { return -ENOTSUP; }
int zmk_keymap_restore_layer(zmk_keymap_layer_id_t id, zmk_keymap_layer_index_t at_index) {
return -ENOTSUP;
}
int zmk_keymap_set_layer_name(zmk_keymap_layer_id_t id, const char *name, size_t size) {
return -ENOTSUP;
}
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
#define PENDING_ARRAY_SIZE DIV_ROUND_UP(ZMK_KEYMAP_LEN, 8)
static uint8_t zmk_keymap_layer_pending_changes[ZMK_KEYMAP_LAYERS_LEN][PENDING_ARRAY_SIZE];
struct zmk_behavior_binding_setting {
zmk_behavior_local_id_t behavior_local_id;
uint32_t param1;
uint32_t param2;
} __packed;
int zmk_keymap_check_unsaved_changes(void) {
for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
uint8_t *pending = zmk_keymap_layer_pending_changes[l];
for (int kp = 0; kp < ZMK_KEYMAP_LEN; kp++) {
if (pending[kp / 8] & BIT(kp % 8)) {
return 1;
}
}
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
if (settings_layer_orders[l] != keymap_layer_orders[l]) {
return 1;
}
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
}
return 0;
}
#define LAYER_ORDER_SETTINGS_KEY "keymap/layer_order"
#define LAYER_NAME_SETTINGS_KEY "keymap/l_n/%d"
#define LAYER_BINDING_SETTINGS_KEY "keymap/l/%d/%d"
static void save_bindings(void) {
for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
uint8_t *pending = zmk_keymap_layer_pending_changes[l];
for (int kp = 0; kp < ZMK_KEYMAP_LEN; kp++) {
if (pending[kp / 8] & BIT(kp % 8)) {
LOG_DBG("Pending save for layer %d at key position %d", l, kp);
struct zmk_behavior_binding *binding = &zmk_keymap[l][kp];
struct zmk_behavior_binding_setting binding_setting = {
.behavior_local_id = zmk_behavior_get_local_id(binding->behavior_dev),
.param1 = binding->param1,
.param2 = binding->param2,
};
// We can skip any trailing zero params, regardless of the behavior
// and if those params are meaningful.
size_t len = sizeof(binding_setting);
if (binding_setting.param2 == 0) {
len -= 4;
if (binding_setting.param1 == 0) {
len -= 4;
}
}
char setting_name[20];
sprintf(setting_name, LAYER_BINDING_SETTINGS_KEY, l, kp);
settings_save_one(setting_name, &binding_setting, len);
}
}
*pending = 0;
}
}
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
static void save_layer_orders(void) {
settings_save_one(LAYER_ORDER_SETTINGS_KEY, keymap_layer_orders,
ARRAY_SIZE(keymap_layer_orders));
memcpy(settings_layer_orders, keymap_layer_orders, ARRAY_SIZE(keymap_layer_orders));
}
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
static void save_layer_names(void) {
for (int id = 0; id < ZMK_KEYMAP_LAYERS_LEN; id++) {
if (changed_layer_names & BIT(id)) {
char setting_name[14];
sprintf(setting_name, LAYER_NAME_SETTINGS_KEY, id);
settings_save_one(setting_name, zmk_keymap_layer_names[id],
strlen(zmk_keymap_layer_names[id]));
}
}
changed_layer_names = 0;
}
int zmk_keymap_save_changes(void) {
save_bindings();
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
save_layer_orders();
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
save_layer_names();
return 0;
}
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
#define KEYMAP_LAYER_ORDER_INIT(n) \
keymap_layer_orders[i] = i; \
settings_layer_orders[i] = i; \
i++;
static void load_stock_keymap_layer_ordering() {
int i = 0;
DT_INST_FOREACH_CHILD_STATUS_OKAY(0, KEYMAP_LAYER_ORDER_INIT)
while (i < ZMK_KEYMAP_LAYERS_LEN) {
keymap_layer_orders[i] = ZMK_KEYMAP_LAYER_ID_INVAL;
i++;
}
}
#endif
static void reload_from_stock_keymap(void) {
for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
for (int k = 0; k < ZMK_KEYMAP_LEN; k++) {
zmk_keymap[l][k] = zmk_stock_keymap[l][k];
}
}
}
int zmk_keymap_discard_changes(void) {
load_stock_keymap_layer_ordering();
reload_from_stock_keymap();
int ret = settings_load_subtree("keymap");
if (ret >= 0) {
changed_layer_names = 0;
for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
memset(zmk_keymap_layer_pending_changes[l], 0, PENDING_ARRAY_SIZE);
}
}
return ret;
}
int zmk_keymap_reset_settings(void) {
settings_delete(LAYER_ORDER_SETTINGS_KEY);
for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
char layer_name_setting_name[14];
sprintf(layer_name_setting_name, LAYER_NAME_SETTINGS_KEY, l);
settings_delete(layer_name_setting_name);
for (int k = 0; k < ZMK_KEYMAP_LEN; k++) {
if (memcmp(&zmk_keymap[l][k], &zmk_stock_keymap[l][k],
sizeof(struct zmk_behavior_binding_setting)) == 0) {
continue;
}
char setting_name[20];
sprintf(setting_name, LAYER_BINDING_SETTINGS_KEY, l, k);
settings_delete(setting_name);
}
}
load_stock_keymap_layer_ordering();
reload_from_stock_keymap();
return 0;
}
#else
int zmk_keymap_save_changes(void) { return -ENOTSUP; }
int zmk_keymap_discard_changes(void) { return -ENOTSUP; }
int zmk_keymap_reset_settings(void) { return -ENOTSUP; }
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
int invoke_locally(struct zmk_behavior_binding *binding, struct zmk_behavior_binding_event event,
bool pressed) {
if (pressed) {
@ -172,24 +585,28 @@ int invoke_locally(struct zmk_behavior_binding *binding, struct zmk_behavior_bin
}
}
int zmk_keymap_apply_position_state(uint8_t source, int layer, uint32_t position, bool pressed,
int64_t timestamp) {
int zmk_keymap_apply_position_state(uint8_t source, zmk_keymap_layer_id_t layer_id,
uint32_t position, bool pressed, int64_t timestamp) {
// We want to make a copy of this, since it may be converted from
// relative to absolute before being invoked
struct zmk_behavior_binding binding = zmk_keymap[layer][position];
ASSERT_LAYER_VAL(layer_id, -EINVAL);
struct zmk_behavior_binding binding = zmk_keymap[layer_id][position];
const struct device *behavior;
struct zmk_behavior_binding_event event = {
.layer = layer,
.layer = layer_id,
.position = position,
.timestamp = timestamp,
};
LOG_DBG("layer: %d position: %d, binding name: %s", layer, position, binding.behavior_dev);
LOG_DBG("layer_id: %d position: %d, binding name: %s", layer_id, position,
binding.behavior_dev);
behavior = zmk_behavior_get_binding(binding.behavior_dev);
if (!behavior) {
LOG_WRN("No behavior assigned to %d on layer %d", position, layer);
LOG_WRN("No behavior assigned to %d on layer %d", position, layer_id);
return 1;
}
@ -236,9 +653,19 @@ int zmk_keymap_position_state_changed(uint8_t source, uint32_t position, bool pr
if (pressed) {
zmk_keymap_active_behavior_layer[position] = _zmk_keymap_layer_state;
}
for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= _zmk_keymap_layer_default; layer--) {
if (zmk_keymap_layer_active_with_state(layer, zmk_keymap_active_behavior_layer[position])) {
int ret = zmk_keymap_apply_position_state(source, layer, position, pressed, timestamp);
// We use int here to be sure we don't loop layer_idx back to UINT8_MAX
for (int layer_idx = ZMK_KEYMAP_LAYERS_LEN - 1;
layer_idx >= LAYER_ID_TO_INDEX(_zmk_keymap_layer_default); layer_idx--) {
zmk_keymap_layer_id_t layer_id = LAYER_INDEX_TO_ID(layer_idx);
if (layer_id == ZMK_KEYMAP_LAYER_ID_INVAL) {
continue;
}
if (zmk_keymap_layer_active_with_state(layer_id,
zmk_keymap_active_behavior_layer[position])) {
int ret =
zmk_keymap_apply_position_state(source, layer_id, position, pressed, timestamp);
if (ret > 0) {
LOG_DBG("behavior processing to continue to next layer");
continue;
@ -260,20 +687,26 @@ int zmk_keymap_sensor_event(uint8_t sensor_index,
size_t channel_data_size, int64_t timestamp) {
bool opaque_response = false;
for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= 0; layer--) {
struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer][sensor_index];
for (int layer_idx = ZMK_KEYMAP_LAYERS_LEN - 1; layer_idx >= 0; layer_idx--) {
uint8_t layer_id = LAYER_INDEX_TO_ID(layer_idx);
LOG_DBG("layer: %d sensor_index: %d, binding name: %s", layer, sensor_index,
binding->behavior_dev);
if (layer_id >= ZMK_KEYMAP_LAYERS_LEN) {
continue;
}
struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer_id][sensor_index];
LOG_DBG("layer idx: %d, layer id: %d sensor_index: %d, binding name: %s", layer_idx,
layer_id, sensor_index, binding->behavior_dev);
const struct device *behavior = zmk_behavior_get_binding(binding->behavior_dev);
if (!behavior) {
LOG_DBG("No behavior assigned to %d on layer %d", sensor_index, layer);
LOG_DBG("No behavior assigned to %d on layer %d", sensor_index, layer_id);
continue;
}
struct zmk_behavior_binding_event event = {
.layer = layer,
.layer = layer_id,
.position = ZMK_VIRTUAL_KEY_POSITION_SENSOR(sensor_index),
.timestamp = timestamp,
};
@ -290,8 +723,8 @@ int zmk_keymap_sensor_event(uint8_t sensor_index,
}
enum behavior_sensor_binding_process_mode mode =
(!opaque_response && layer >= _zmk_keymap_layer_default &&
zmk_keymap_layer_active(layer))
(!opaque_response && layer_idx >= LAYER_ID_TO_INDEX(_zmk_keymap_layer_default) &&
zmk_keymap_layer_active(layer_id))
? BEHAVIOR_SENSOR_BINDING_PROCESS_MODE_TRIGGER
: BEHAVIOR_SENSOR_BINDING_PROCESS_MODE_DISCARD;
@ -335,3 +768,137 @@ ZMK_SUBSCRIPTION(keymap, zmk_position_state_changed);
#if ZMK_KEYMAP_HAS_SENSORS
ZMK_SUBSCRIPTION(keymap, zmk_sensor_event);
#endif /* ZMK_KEYMAP_HAS_SENSORS */
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
static int keymap_handle_set(const char *name, size_t len, settings_read_cb read_cb, void *cb_arg) {
const char *next;
LOG_DBG("Setting Keymap setting %s", name);
if (settings_name_steq(name, "l_n", &next) && next) {
char *endptr;
zmk_keymap_layer_id_t layer = strtoul(next, &endptr, 10);
if (*endptr != '\0') {
LOG_WRN("Invalid layer number: %s with endptr %s", next, endptr);
return -EINVAL;
}
if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
LOG_WRN("Found layer name for invalid layer ID %d", layer);
}
int err = read_cb(cb_arg, zmk_keymap_layer_names[layer],
MIN(len, CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN - 1));
if (err <= 0) {
LOG_ERR("Failed to handle keymap layer name from settings (err %d)", err);
return err;
}
} else if (settings_name_steq(name, "l", &next) && next) {
char *endptr;
uint8_t layer = strtoul(next, &endptr, 10);
if (*endptr != '/') {
LOG_WRN("Invalid layer number: %s with endptr %s", next, endptr);
return -EINVAL;
}
uint8_t key_position = strtoul(endptr + 1, &endptr, 10);
if (*endptr != '\0') {
LOG_WRN("Invalid key_position number: %s with endptr %s", next, endptr);
return -EINVAL;
}
if (len > sizeof(struct zmk_behavior_binding_setting)) {
LOG_ERR("Too large binding setting size (got %d expected %d)", len,
sizeof(struct zmk_behavior_binding_setting));
return -EINVAL;
}
if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
LOG_WRN("Layer %d is larger than max of %d", layer, ZMK_KEYMAP_LAYERS_LEN);
return -EINVAL;
}
if (key_position >= ZMK_KEYMAP_LEN) {
LOG_WRN("Key position %d is larger than max of %d", key_position, ZMK_KEYMAP_LEN);
return -EINVAL;
}
struct zmk_behavior_binding_setting binding_setting = {0};
int err = read_cb(cb_arg, &binding_setting, len);
if (err <= 0) {
LOG_ERR("Failed to handle keymap binding from settings (err %d)", err);
return err;
}
const char *name =
zmk_behavior_find_behavior_name_from_local_id(binding_setting.behavior_local_id);
if (!name) {
LOG_WRN("Loaded device %d from settings but no device found by that local ID",
binding_setting.behavior_local_id);
}
zmk_keymap[layer][key_position] = (struct zmk_behavior_binding){
.local_id = binding_setting.behavior_local_id,
.behavior_dev = name,
.param1 = binding_setting.param1,
.param2 = binding_setting.param2,
};
}
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
else if (settings_name_steq(name, "layer_order", &next) && !next) {
int err =
read_cb(cb_arg, settings_layer_orders, MIN(len, ARRAY_SIZE(settings_layer_orders)));
if (err <= 0) {
LOG_ERR("Failed to handle keymap layer orders from settings (err %d)", err);
return err;
}
LOG_HEXDUMP_DBG(settings_layer_orders, ARRAY_SIZE(settings_layer_orders),
"Settings Layer Order");
memcpy(keymap_layer_orders, settings_layer_orders,
MIN(len, ARRAY_SIZE(settings_layer_orders)));
}
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
return 0;
};
static int keymap_handle_commit(void) {
for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
for (int p = 0; p < ZMK_KEYMAP_LEN; p++) {
struct zmk_behavior_binding *binding = &zmk_keymap[l][p];
if (binding->local_id > 0 && !binding->behavior_dev) {
binding->behavior_dev =
zmk_behavior_find_behavior_name_from_local_id(binding->local_id);
if (!binding->behavior_dev) {
LOG_ERR("Failed to finding device for local ID %d after settings load",
binding->local_id);
}
}
}
}
return 0;
}
SETTINGS_STATIC_HANDLER_DEFINE(keymap, "keymap", NULL, keymap_handle_set, keymap_handle_commit,
NULL);
#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
int keymap_init(void) {
#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
load_stock_keymap_layer_ordering();
#endif
return 0;
}
SYS_INIT(keymap_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

37
app/src/physical_layouts.c
View file

@ -72,9 +72,17 @@ struct position_map_entry {
const uint32_t positions[ZMK_POS_MAP_LEN];
};
#define ZMK_POS_MAP_LEN_CHECK(node_id) \
BUILD_ASSERT(ZMK_POS_MAP_LEN == DT_PROP_LEN(node_id, positions), \
"Position maps must all have the same number of entries")
DT_FOREACH_CHILD_SEP(DT_INST(0, POS_MAP_COMPAT), ZMK_POS_MAP_LEN_CHECK, (;));
#define ZMK_POS_MAP_ENTRY(node_id) \
{ \
.layout = &_CONCAT(_zmk_physical_layout_, DT_PHANDLE(node_id, physical_layout)), \
.layout = COND_CODE_1( \
DT_HAS_COMPAT_STATUS_OKAY(DT_PHANDLE(node_id, physical_layout)), \
(&_CONCAT(_zmk_physical_layout_, DT_PHANDLE(node_id, physical_layout))), (NULL)), \
.positions = DT_PROP(node_id, positions), \
}
@ -275,13 +283,15 @@ int zmk_physical_layouts_save_selected(void) {
int zmk_physical_layouts_revert_selected(void) { return zmk_physical_layouts_select_initial(); }
int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, uint32_t *map) {
int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, size_t map_size,
uint32_t map[map_size]) {
if (source >= ARRAY_SIZE(layouts) || dest >= ARRAY_SIZE(layouts)) {
return -EINVAL;
}
const struct zmk_physical_layout *src_layout = layouts[source];
const struct zmk_physical_layout *dest_layout = layouts[dest];
int max_kp = dest_layout->keys_len;
#if HAVE_POS_MAP
const struct position_map_entry *src_pos_map = NULL;
@ -296,11 +306,24 @@ int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, uint32_t
dest_pos_map = &positions_maps[pm];
}
}
// Maps can place items "off the end" of other layouts so they are
// preserved but not visible, so adjust our max here if that is being used.
if (src_pos_map && dest_pos_map) {
for (int mp = 0; mp < ZMK_POS_MAP_LEN; mp++) {
max_kp =
MAX(max_kp, MAX(src_pos_map->positions[mp] + 1, dest_pos_map->positions[mp] + 1));
}
}
#endif
memset(map, UINT32_MAX, dest_layout->keys_len);
if (map_size < max_kp) {
return -EINVAL;
}
for (int b = 0; b < dest_layout->keys_len; b++) {
memset(map, UINT32_MAX, map_size);
for (int b = 0; b < max_kp; b++) {
bool found = false;
#if HAVE_POS_MAP
@ -329,13 +352,9 @@ int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, uint32_t
}
}
#endif
if (!found || map[b] >= src_layout->keys_len) {
map[b] = UINT32_MAX;
}
}
return dest_layout->keys_len;
return max_kp;
}
#if IS_ENABLED(CONFIG_SETTINGS)

2
app/src/studio/CMakeLists.txt
View file

@ -3,6 +3,7 @@
zephyr_linker_sources(DATA_SECTIONS ../../include/linker/zmk-rpc-subsystems.ld)
zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-subsystem-handlers.ld)
zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-subsystem-settings-reset.ld)
zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-event-mappers.ld)
zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-transport.ld)
@ -11,5 +12,6 @@ target_sources(app PRIVATE rpc.c)
target_sources(app PRIVATE core.c)
target_sources(app PRIVATE behavior_subsystem.c)
target_sources(app PRIVATE core_subsystem.c)
target_sources(app PRIVATE keymap_subsystem.c)
target_sources_ifdef(CONFIG_ZMK_STUDIO_TRANSPORT_UART app PRIVATE uart_rpc_transport.c)
target_sources_ifdef(CONFIG_ZMK_STUDIO_TRANSPORT_BLE app PRIVATE gatt_rpc_transport.c)

2
app/src/studio/Kconfig
View file

@ -41,6 +41,8 @@ menuconfig ZMK_STUDIO_RPC
select ZMK_BEHAVIOR_METADATA
select ZMK_BEHAVIOR_LOCAL_IDS
select RING_BUFFER
select ZMK_KEYMAP_SETTINGS_STORAGE
select ZMK_KEYMAP_LAYER_REORDERING
help
Add firmware support for studio RPC protocol

13
app/src/studio/core_subsystem.c
View file

@ -61,8 +61,21 @@ zmk_studio_Response get_lock_state(const zmk_studio_Request *req) {
return CORE_RESPONSE(get_lock_state, resp);
}
zmk_studio_Response reset_settings(const zmk_studio_Request *req) {
ZMK_RPC_SUBSYSTEM_SETTINGS_RESET_FOREACH(sub) {
int ret = sub->callback();
if (ret < 0) {
LOG_ERR("Failed to reset settings: %d", ret);
return CORE_RESPONSE(reset_settings, false);
}
}
return CORE_RESPONSE(reset_settings, true);
}
ZMK_RPC_SUBSYSTEM_HANDLER(core, get_device_info, ZMK_STUDIO_RPC_HANDLER_UNSECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(core, get_lock_state, ZMK_STUDIO_RPC_HANDLER_UNSECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(core, reset_settings, ZMK_STUDIO_RPC_HANDLER_SECURED);
static int core_event_mapper(const zmk_event_t *eh, zmk_studio_Notification *n) {
struct zmk_studio_core_lock_state_changed *lock_ev = as_zmk_studio_core_lock_state_changed(eh);

539
app/src/studio/keymap_subsystem.c Normal file
View file

@ -0,0 +1,539 @@
/*
* Copyright (c) 2024 The ZMK Contributors
*
* SPDX-License-Identifier: MIT
*/
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(zmk_studio, CONFIG_ZMK_STUDIO_LOG_LEVEL);
#include <drivers/behavior.h>
#include <zmk/behavior.h>
#include <zmk/matrix.h>
#include <zmk/keymap.h>
#include <zmk/studio/rpc.h>
#include <zmk/physical_layouts.h>
#include <pb_encode.h>
ZMK_RPC_SUBSYSTEM(keymap)
#define KEYMAP_RESPONSE(type, ...) ZMK_RPC_RESPONSE(keymap, type, __VA_ARGS__)
#define KEYMAP_NOTIFICATION(type, ...) ZMK_RPC_NOTIFICATION(keymap, type, __VA_ARGS__)
static bool encode_layer_bindings(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
const zmk_keymap_layer_id_t layer_id = *(uint8_t *)*arg;
for (int b = 0; b < ZMK_KEYMAP_LEN; b++) {
const struct zmk_behavior_binding *binding =
zmk_keymap_get_layer_binding_at_idx(layer_id, b);
zmk_keymap_BehaviorBinding bb = zmk_keymap_BehaviorBinding_init_zero;
if (binding && binding->behavior_dev) {
bb.behavior_id = zmk_behavior_get_local_id(binding->behavior_dev);
bb.param1 = binding->param1;
bb.param2 = binding->param2;
}
if (!pb_encode_tag_for_field(stream, field)) {
return false;
}
if (!pb_encode_submessage(stream, &zmk_keymap_BehaviorBinding_msg, &bb)) {
return false;
}
}
return true;
}
static bool encode_layer_name(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
const zmk_keymap_layer_index_t layer_idx = *(uint8_t *)*arg;
const char *name = zmk_keymap_layer_name(layer_idx);
if (!name) {
return true;
}
if (!pb_encode_tag_for_field(stream, field)) {
return false;
}
return pb_encode_string(stream, name, strlen(name));
}
static bool encode_keymap_layers(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
for (zmk_keymap_layer_index_t l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
zmk_keymap_layer_id_t layer_id = zmk_keymap_layer_index_to_id(l);
if (layer_id == UINT8_MAX) {
break;
}
if (!pb_encode_tag_for_field(stream, field)) {
LOG_WRN("Failed to encode tag");
return false;
}
zmk_keymap_Layer layer = zmk_keymap_Layer_init_zero;
layer.id = layer_id;
layer.name.funcs.encode = encode_layer_name;
layer.name.arg = &layer_id;
layer.bindings.funcs.encode = encode_layer_bindings;
layer.bindings.arg = &layer_id;
if (!pb_encode_submessage(stream, &zmk_keymap_Layer_msg, &layer)) {
LOG_WRN("Failed to encode layer submessage");
return false;
}
}
return true;
}
zmk_studio_Response get_keymap(const zmk_studio_Request *req) {
zmk_keymap_Keymap resp = zmk_keymap_Keymap_init_zero;
resp.layers.funcs.encode = encode_keymap_layers;
resp.available_layers = 0;
for (zmk_keymap_layer_index_t index = 0; index < ZMK_KEYMAP_LAYERS_LEN; index++) {
zmk_keymap_layer_id_t id = zmk_keymap_layer_index_to_id(index);
if (id == UINT8_MAX) {
resp.available_layers = ZMK_KEYMAP_LAYERS_LEN - index;
break;
}
}
return KEYMAP_RESPONSE(get_keymap, resp);
}
zmk_studio_Response set_layer_binding(const zmk_studio_Request *req) {
const zmk_keymap_SetLayerBindingRequest *set_req =
&req->subsystem.keymap.request_type.set_layer_binding;
zmk_behavior_local_id_t bid = set_req->binding.behavior_id;
const char *behavior_name = zmk_behavior_find_behavior_name_from_local_id(bid);
if (!behavior_name) {
return KEYMAP_RESPONSE(
set_layer_binding,
zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_INVALID_BEHAVIOR);
}
struct zmk_behavior_binding binding = (struct zmk_behavior_binding){
.behavior_dev = behavior_name,
.param1 = set_req->binding.param1,
.param2 = set_req->binding.param2,
};
int ret = zmk_behavior_validate_binding(&binding);
if (ret < 0) {
return KEYMAP_RESPONSE(
set_layer_binding,
zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_INVALID_PARAMETERS);
}
ret = zmk_keymap_set_layer_binding_at_idx(set_req->layer_id, set_req->key_position, binding);
if (ret < 0) {
LOG_WRN("Setting the binding failed with %d", ret);
switch (ret) {
case -EINVAL:
return KEYMAP_RESPONSE(
set_layer_binding,
zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_INVALID_LOCATION);
default:
return ZMK_RPC_SIMPLE_ERR(GENERIC);
}
}
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
return KEYMAP_RESPONSE(set_layer_binding,
zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_OK);
}
zmk_studio_Response check_unsaved_changes(const zmk_studio_Request *req) {
int layout_changes = zmk_physical_layouts_check_unsaved_selection();
int keymap_changes = zmk_keymap_check_unsaved_changes();
return KEYMAP_RESPONSE(check_unsaved_changes, layout_changes > 0 || keymap_changes > 0);
}
zmk_studio_Response save_changes(const zmk_studio_Request *req) {
int ret = zmk_physical_layouts_save_selected();
if (ret < 0) {
return ZMK_RPC_SIMPLE_ERR(GENERIC);
}
ret = zmk_keymap_save_changes();
if (ret < 0) {
return ZMK_RPC_SIMPLE_ERR(GENERIC);
}
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, false)});
return KEYMAP_RESPONSE(save_changes, true);
}
zmk_studio_Response discard_changes(const zmk_studio_Request *req) {
int ret = zmk_physical_layouts_revert_selected();
if (ret < 0) {
return ZMK_RPC_SIMPLE_ERR(GENERIC);
}
ret = zmk_keymap_discard_changes();
if (ret < 0) {
return ZMK_RPC_SIMPLE_ERR(GENERIC);
}
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, false)});
return KEYMAP_RESPONSE(discard_changes, true);
}
static int keymap_settings_reset(void) { return zmk_keymap_reset_settings(); }
ZMK_RPC_SUBSYSTEM_SETTINGS_RESET(keymap, keymap_settings_reset);
static bool encode_layout_name(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
struct zmk_physical_layout *layout = (struct zmk_physical_layout *)*arg;
if (!layout->display_name) {
return true;
}
if (!pb_encode_tag_for_field(stream, field)) {
LOG_WRN("Failed to encode tag");
return false;
}
pb_encode_string(stream, layout->display_name, strlen(layout->display_name));
return true;
}
static bool encode_layout_keys(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
struct zmk_physical_layout *layout = (struct zmk_physical_layout *)*arg;
for (int kp = 0; kp < layout->keys_len; kp++) {
const struct zmk_key_physical_attrs *layout_kp = &layout->keys[kp];
if (!pb_encode_tag_for_field(stream, field)) {
LOG_WRN("Failed to encode tag");
return false;
}
zmk_keymap_KeyPhysicalAttrs layout_kp_msg = {
.width = layout_kp->width,
.height = layout_kp->height,
.x = layout_kp->x,
.y = layout_kp->y,
.r = layout_kp->r,
.rx = layout_kp->rx,
.ry = layout_kp->ry,
};
if (!pb_encode_submessage(stream, &zmk_keymap_KeyPhysicalAttrs_msg, &layout_kp_msg)) {
LOG_WRN("Failed to encode layout key position submessage");
return false;
}
}
return true;
}
static bool encode_layouts(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
struct zmk_physical_layout const *const *layouts;
const size_t layout_count = zmk_physical_layouts_get_list(&layouts);
for (int i = 0; i < layout_count; i++) {
const struct zmk_physical_layout *l = layouts[i];
if (!pb_encode_tag_for_field(stream, field)) {
LOG_WRN("Failed to encode tag");
return false;
}
zmk_keymap_PhysicalLayout layout = zmk_keymap_PhysicalLayout_init_zero;
layout.name.funcs.encode = encode_layout_name;
layout.name.arg = l;
layout.keys.funcs.encode = encode_layout_keys;
layout.keys.arg = l;
if (!pb_encode_submessage(stream, &zmk_keymap_PhysicalLayout_msg, &layout)) {
LOG_WRN("Failed to encode layout submessage");
return false;
}
}
return true;
}
zmk_studio_Response get_physical_layouts(const zmk_studio_Request *req) {
zmk_keymap_PhysicalLayouts resp = zmk_keymap_PhysicalLayouts_init_zero;
resp.active_layout_index = zmk_physical_layouts_get_selected();
resp.layouts.funcs.encode = encode_layouts;
return KEYMAP_RESPONSE(get_physical_layouts, resp);
}
static void migrate_keymap(const uint8_t old) {
int new = zmk_physical_layouts_get_selected();
uint32_t new_to_old_map[ZMK_KEYMAP_LEN];
int layout_size =
zmk_physical_layouts_get_position_map(old, new, ZMK_KEYMAP_LEN, new_to_old_map);
if (layout_size < 0) {
return;
}
for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
struct zmk_behavior_binding new_layer[ZMK_KEYMAP_LEN];
for (int b = 0; b < layout_size; b++) {
uint32_t old_b = new_to_old_map[b];
if (old_b == UINT32_MAX) {
memset(&new_layer[b], 0, sizeof(struct zmk_behavior_binding));
continue;
}
const struct zmk_behavior_binding *binding =
zmk_keymap_get_layer_binding_at_idx(l, old_b);
if (!binding) {
memset(&new_layer[b], 0, sizeof(struct zmk_behavior_binding));
continue;
}
memcpy(&new_layer[b], binding, sizeof(struct zmk_behavior_binding));
}
for (int b = 0; b < layout_size; b++) {
zmk_keymap_set_layer_binding_at_idx(l, b, new_layer[b]);
}
}
// TODO: Migrate combos?
}
zmk_studio_Response set_active_physical_layout(const zmk_studio_Request *req) {
uint8_t index = (uint8_t)req->subsystem.keymap.request_type.set_active_physical_layout;
int old = zmk_physical_layouts_get_selected();
zmk_keymap_SetActivePhysicalLayoutResponse resp =
zmk_keymap_SetActivePhysicalLayoutResponse_init_zero;
resp.which_result = zmk_keymap_SetActivePhysicalLayoutResponse_ok_tag;
resp.result.ok.layers.funcs.encode = encode_keymap_layers;
if (old == index) {
return KEYMAP_RESPONSE(set_active_physical_layout, resp);
}
int ret = zmk_physical_layouts_select(index);
if (ret >= 0) {
migrate_keymap(old);
} else {
resp.which_result = zmk_keymap_SetActivePhysicalLayoutResponse_err_tag;
resp.result.err =
zmk_keymap_SetActivePhysicalLayoutErrorCode_SET_ACTIVE_PHYSICAL_LAYOUT_ERR_GENERIC;
}
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
return KEYMAP_RESPONSE(set_active_physical_layout, resp);
}
zmk_studio_Response move_layer(const zmk_studio_Request *req) {
const zmk_keymap_MoveLayerRequest *move_req = &req->subsystem.keymap.request_type.move_layer;
zmk_keymap_MoveLayerResponse resp = zmk_keymap_MoveLayerResponse_init_zero;
int ret = zmk_keymap_move_layer(move_req->start_index, move_req->dest_index);
if (ret >= 0) {
resp.which_result = zmk_keymap_SetActivePhysicalLayoutResponse_ok_tag;
resp.result.ok.layers.funcs.encode = encode_keymap_layers;
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
} else {
LOG_WRN("Failed to move layer: %d", ret);
resp.which_result = zmk_keymap_MoveLayerResponse_err_tag;
resp.result.err = zmk_keymap_MoveLayerErrorCode_MOVE_LAYER_ERR_GENERIC;
}
return KEYMAP_RESPONSE(move_layer, resp);
}
zmk_studio_Response add_layer(const zmk_studio_Request *req) {
// Use a static here to keep the value valid during serialization
static zmk_keymap_layer_id_t layer_id = 0;
zmk_keymap_AddLayerResponse resp = zmk_keymap_AddLayerResponse_init_zero;
int ret = zmk_keymap_add_layer();
if (ret >= 0) {
layer_id = zmk_keymap_layer_index_to_id(ret);
resp.which_result = zmk_keymap_AddLayerResponse_ok_tag;
resp.result.ok.index = ret;
resp.result.ok.has_layer = true;
resp.result.ok.layer.id = layer_id;
resp.result.ok.layer.name.funcs.encode = encode_layer_name;
resp.result.ok.layer.name.arg = &layer_id;
resp.result.ok.layer.bindings.funcs.encode = encode_layer_bindings;
resp.result.ok.layer.bindings.arg = &layer_id;
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
} else {
LOG_WRN("Failed to add layer: %d", ret);
resp.which_result = zmk_keymap_AddLayerResponse_err_tag;
switch (ret) {
case -ENOSPC:
resp.result.err = zmk_keymap_AddLayerErrorCode_ADD_LAYER_ERR_NO_SPACE;
break;
default:
resp.result.err = zmk_keymap_AddLayerErrorCode_ADD_LAYER_ERR_GENERIC;
break;
}
}
return KEYMAP_RESPONSE(add_layer, resp);
}
zmk_studio_Response remove_layer(const zmk_studio_Request *req) {
const zmk_keymap_RemoveLayerRequest *rm_req = &req->subsystem.keymap.request_type.remove_layer;
zmk_keymap_RemoveLayerResponse resp = zmk_keymap_RemoveLayerResponse_init_zero;
int ret = zmk_keymap_remove_layer(rm_req->layer_index);
if (ret >= 0) {
resp.which_result = zmk_keymap_RemoveLayerResponse_ok_tag;
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
} else {
LOG_WRN("Failed to rm layer: %d", ret);
resp.which_result = zmk_keymap_RemoveLayerResponse_err_tag;
switch (ret) {
case -EINVAL:
resp.result.err = zmk_keymap_RemoveLayerErrorCode_REMOVE_LAYER_ERR_INVALID_INDEX;
break;
default:
resp.result.err = zmk_keymap_RemoveLayerErrorCode_REMOVE_LAYER_ERR_GENERIC;
break;
}
}
return KEYMAP_RESPONSE(remove_layer, resp);
}
zmk_studio_Response restore_layer(const zmk_studio_Request *req) {
const zmk_keymap_RestoreLayerRequest *restore_req =
&req->subsystem.keymap.request_type.restore_layer;
zmk_keymap_RestoreLayerResponse resp = zmk_keymap_RestoreLayerResponse_init_zero;
int ret = zmk_keymap_restore_layer(restore_req->layer_id, restore_req->at_index);
if (ret >= 0) {
resp.which_result = zmk_keymap_RemoveLayerResponse_ok_tag;
resp.result.ok.id = restore_req->layer_id;
resp.result.ok.name.funcs.encode = encode_layer_name;
resp.result.ok.name.arg = &restore_req->layer_id;
resp.result.ok.bindings.funcs.encode = encode_layer_bindings;
resp.result.ok.bindings.arg = &restore_req->layer_id;
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
} else {
LOG_WRN("Failed to restore layer: %d", ret);
resp.which_result = zmk_keymap_RestoreLayerResponse_err_tag;
switch (ret) {
case -EINVAL:
resp.result.err = zmk_keymap_RestoreLayerErrorCode_RESTORE_LAYER_ERR_INVALID_INDEX;
break;
default:
resp.result.err = zmk_keymap_RestoreLayerErrorCode_RESTORE_LAYER_ERR_GENERIC;
break;
}
}
return KEYMAP_RESPONSE(restore_layer, resp);
}
zmk_studio_Response set_layer_props(const zmk_studio_Request *req) {
const zmk_keymap_SetLayerPropsRequest *set_req =
&req->subsystem.keymap.request_type.set_layer_props;
zmk_keymap_SetLayerPropsResponse resp =
zmk_keymap_SetLayerPropsResponse_SET_LAYER_PROPS_RESP_OK;
if (strlen(set_req->name) <= 0) {
return KEYMAP_RESPONSE(set_layer_props, resp);
}
int ret = zmk_keymap_set_layer_name(set_req->layer_id, set_req->name, strlen(set_req->name));
if (ret >= 0) {
raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
.notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
} else {
LOG_WRN("Failed to set layer props: %d", ret);
switch (ret) {
case -EINVAL:
resp = zmk_keymap_SetLayerPropsResponse_SET_LAYER_PROPS_RESP_ERR_INVALID_ID;
break;
default:
resp = zmk_keymap_SetLayerPropsResponse_SET_LAYER_PROPS_RESP_ERR_GENERIC;
break;
}
}
return KEYMAP_RESPONSE(set_layer_props, resp);
}
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, get_keymap, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, set_layer_binding, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, check_unsaved_changes, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, save_changes, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, discard_changes, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, get_physical_layouts, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, set_active_physical_layout, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, move_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, add_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, remove_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, restore_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
ZMK_RPC_SUBSYSTEM_HANDLER(keymap, set_layer_props, ZMK_STUDIO_RPC_HANDLER_SECURED);
static int event_mapper(const zmk_event_t *eh, zmk_studio_Notification *n) { return 0; }
ZMK_RPC_EVENT_MAPPER(keymap, event_mapper);

8
app/tests/macros/press-mid-macro/keycode_events.snapshot
View file

@ -1,8 +1,8 @@
pos_state: layer: 0 position: 0, binding name: abc_macro
pos_state: layer_id: 0 position: 0, binding name: abc_macro
kp_pressed: usage_page 0x07 keycode 0x04 implicit_mods 0x00 explicit_mods 0x00
pos_state: layer: 0 position: 0, binding name: abc_macro
pos_state: layer: 0 position: 1, binding name: momentary_layer
pos_state: layer: 0 position: 1, binding name: momentary_layer
pos_state: layer_id: 0 position: 0, binding name: abc_macro
pos_state: layer_id: 0 position: 1, binding name: momentary_layer
pos_state: layer_id: 0 position: 1, binding name: momentary_layer
kp_released: usage_page 0x07 keycode 0x04 implicit_mods 0x00 explicit_mods 0x00
kp_pressed: usage_page 0x07 keycode 0x05 implicit_mods 0x00 explicit_mods 0x00
kp_released: usage_page 0x07 keycode 0x05 implicit_mods 0x00 explicit_mods 0x00

2
app/west.yml
View file

@ -34,7 +34,7 @@ manifest:
path: modules/lib/nanopb
remote: zephyrproject-rtos
- name: zmk-studio-messages
revision: 42446798e357e8021c5202a01ea250a34a776e85
revision: a79267a9661241a6603b6da3d2b3f71e8023a9d9
path: modules/msgs/zmk-studio-messages
remote: zmkfirmware
self: