fix: correctly set keycodes

Author: mishamyrt

cmd/effects/main.go

@@ -2,9 +2,9 @@
 package main
 
 import (
-	"fmt"
-
 	"github.com/mishamyrt/nuga-lib"
+	"github.com/mishamyrt/nuga-lib/features/keys"
+	"github.com/mishamyrt/nuga-lib/layout"
 	"github.com/mishamyrt/nuga-lib/packages/cli"
 )
 
@@ -20,23 +20,40 @@ var (
 		Run: func(_ []string) {
 			dev, err := nuga.Open()
 			cli.Must("open device", err)
-			effects, err := dev.Features.Light.GetEffects()
-			cli.Must("get effects", err)
-			fmt.Println("Backlight")
-			fmt.Printf("  Mode: %v\n", effects.Backlight.Mode.Name)
-			fmt.Printf("  Color: %v\n", effects.Backlight.CurrentParams().Color)
-			fmt.Printf("  Brightness: %v\n", effects.Backlight.CurrentParams().Brightness)
-			fmt.Printf("  Speed: %v\n", effects.Backlight.CurrentParams().Speed)
-			fmt.Println("Halo")
-			fmt.Printf("  Mode: %v\n", effects.Halo.Mode.Name)
-			fmt.Printf("  Color: %v\n", effects.Halo.Color)
-			fmt.Printf("  Brightness: %v\n", effects.Halo.Brightness)
-			fmt.Printf("  Speed: %v\n", effects.Halo.Speed)
-			fmt.Println("Sidelight")
-			fmt.Printf("  Mode: %v\n", effects.Sidelight.Mode.Name)
-			fmt.Printf("  Color: %v\n", effects.Sidelight.Color)
-			fmt.Printf("  Brightness: %v\n", effects.Sidelight.Brightness)
-			fmt.Printf("  Speed: %v\n", effects.Sidelight.Speed)
+			// effects, err := dev.Features.Light.GetEffects()
+			// cli.Must("get effects", err)
+			keyMap, err := dev.Features.Keys.GetMac()
+			cli.Must("get keymap", err)
+			keyMap.SetKey(layout.KeyB, keys.Key{
+				Type: keys.ActionKeystroke,
+				Keystroke: &keys.KeystrokeParams{
+					Name:      layout.KeyA,
+					Modifiers: nil,
+				},
+			})
+			// err = dev.Features.Keys.SetMac(keyMap)
+			// cli.Must("set keymap", err)
+			// localMap := *keyMap
+			// fmt.Println(localMap[layout.KeyHome].Keystroke.Name)
+			// keyMap.Bytes(layout.GetKeystrokeTemplate(dev.Name))
+			// data, err := json.Marshal(&keyMap)
+			// cli.Must("marshal effects", err)
+			// fmt.Println(string(data))fghbccbcbnnnnnxzzsdfhfgjeryiyui
+			// fmt.Println("Backlight")gh
+			// fmt.Printf("  Mode: %v\n", effects.Backlight.Mode.Name)
+			// fmt.Printf("  Color: %v\n", effects.Backlight.CurrentParams().Color)
+			// fmt.Printf("  Brightness: %v\n", effects.Backlight.CurrentParams().Brightness)
+			// fmt.Printf("  Speed: %v\n", effects.Backlight.CurrentParams().Speed)
+			// fmt.Println("Halo")
+			// fmt.Printf("  Mode: %v\n", effects.Halo.Mode.Name)
+			// fmt.Printf("  Color: %v\n", effects.Halo.Color)
+			// fmt.Printf("  Brightness: %v\n", effects.Halo.Brightness)
+			// fmt.Printf("  Speed: %v\n", effects.Halo.Speed)
+			// fmt.Println("Sidelight")
+			// fmt.Printf("  Mode: %v\n", effects.Sidelight.Mode.Name)
+			// fmt.Printf("  Color: %v\n", effects.Sidelight.Color)
+			// fmt.Printf("  Brightness: %v\n", effects.Sidelight.Brightness)
+			// fmt.Printf("  Speed: %v\n", effects.Sidelight.Speed)
 		},
 	}
 )

examples/keycodes/main.go

@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/mishamyrt/nuga-lib/dump"
+	"github.com/mishamyrt/nuga-lib/device"
 	"github.com/mishamyrt/nuga-lib/examples/keycodes/annotation"
 	"github.com/mishamyrt/nuga-lib/examples/keycodes/keymap"
 	"github.com/mishamyrt/nuga-lib/features/keys"
@@ -25,7 +25,7 @@ func main() {
 	if err != nil {
 		die("Error reading file: %v", err)
 	}
-	var state dump.State
+	var state device.State
 	err = json.Unmarshal(data, &state)
 	if err != nil {
 		die("Error unmarshalling: %v", err)

features/features.go

@@ -22,8 +22,8 @@ type LightFeature interface {
 	SetBacklightColors(*light.BacklightColors) error
 	GetCustomEffect() (*light.CustomEffectMap, error)
 	SetCustomEffect(*light.CustomEffectMap) error
-	GetStateData() (*light.StateData, error)
-	SetStateData(*light.StateData) error
+	GetStateData() (*device.LightsState, error)
+	SetStateData(*device.LightsState) error
 }
 
 // KeysFeature represents keyboard keys feature
@@ -34,14 +34,18 @@ type KeysFeature interface {
 	SetMac(keyMap *keys.KeyMap) error
 	GetMacros() (keys.Macros, error)
 	SetMacros(macros keys.Macros) error
-	GetStateData() (*keys.StateData, error)
-	SetStateData(*keys.StateData) error
+	GetStateData() (*device.KeysState, error)
+	SetStateData(*device.KeysState) error
 }
 
 // New creates Features instance with handle
-func New(dev hid.Handler, model device.Model) *Features {
+func New(dev hid.Handler, model device.Model) (*Features, error) {
+	k, err := keys.New(dev, model)
+	if err != nil {
+		return nil, err
+	}
 	return &Features{
 		Light: light.New(dev, model),
-		Keys:  keys.New(dev, model),
-	}
+		Keys:  k,
+	}, nil
 }

features/keys/errors.go

@@ -16,3 +16,6 @@ var ErrWrongMacroHeader = errors.New("wrong macro header. Must be 0x85")
 
 // ErrWrongLength is returned when slice length is wrong
 var ErrWrongLength = errors.New("slice should be of length 4")
+
+// ErrKeyNotFound is returned when key not found
+var ErrKeyNotFound = errors.New("key not found")

features/keys/feature.go

@@ -11,24 +11,35 @@ import (
 type Feature struct {
 	handle   hid.Handler
 	template *layout.Template
+	defaults *device.KeysState
 }
 
 // New creates keys feature instance.
-func New(handle hid.Handler, model device.Model) *Feature {
+func New(handle hid.Handler, model device.Model) (*Feature, error) {
+	template := layout.GetKeystrokeTemplate(model)
+	state, err := device.GetDefaults(model)
+	if err != nil {
+		return nil, err
+	}
 	return &Feature{
 		handle:   handle,
-		template: layout.GetKeystrokeTemplate(model),
-	}
+		template: template,
+		defaults: state.Data.Keys,
+	}, nil
 }
 
 // GetWin returns win keyboard keys
 func (f *Feature) GetWin() (*KeyMap, error) {
-	return f.getKeys(cmdGetWinKeys)
+	m, err := f.getKeys(cmdGetWinKeys)
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
 }
 
 // SetWin sets win keyboard keys
 func (f *Feature) SetWin(keyMap *KeyMap) error {
-	return f.setKeys(cmdSetWinKeys, keyMap)
+	return f.setKeys(cmdSetWinKeys, keyMap, f.defaults.Win)
 }
 
 // GetMac returns mac keyboard keys
@@ -38,7 +49,7 @@ func (f *Feature) GetMac() (*KeyMap, error) {
 
 // SetMac sets mac keyboard keys
 func (f *Feature) SetMac(keyMap *KeyMap) error {
-	return f.setKeys(cmdSetMacKeys, keyMap)
+	return f.setKeys(cmdSetMacKeys, keyMap, f.defaults.Mac)
 }
 
 // GetRawMacros returns raw keyboard macros
@@ -77,7 +88,7 @@ func (f *Feature) SetMacros(macros Macros) error {
 }
 
 // GetStateData returns current raw keys state
-func (f *Feature) GetStateData() (*StateData, error) {
+func (f *Feature) GetStateData() (*device.KeysState, error) {
 	mac, err := f.getRawKeys(cmdGetMacKeys)
 	if err != nil {
 		return nil, err
@@ -90,15 +101,15 @@ func (f *Feature) GetStateData() (*StateData, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &StateData{
+	return &device.KeysState{
 		Mac:    mac,
 		Win:    win,
 		Macros: macros,
 	}, nil
 }
 
 // SetStateData sets current raw keys state
-func (f *Feature) SetStateData(data *StateData) error {
+func (f *Feature) SetStateData(data *device.KeysState) error {
 	if err := f.setRawKeys(cmdSetMacKeys, data.Mac); err != nil {
 		return err
 	}
@@ -142,10 +153,10 @@ func (f *Feature) getKeys(cmd []byte) (*KeyMap, error) {
 	return keys, nil
 }
 
-func (f *Feature) setKeys(cmdSet []byte, keys *KeyMap) error {
+func (f *Feature) setKeys(cmdSet []byte, keys *KeyMap, defaults []byte) error {
 	if f.template == nil {
 		return ErrNoTemplate
 	}
-	raw := keys.Bytes(f.template)
+	raw := keys.Bytes(f.template, defaults)
 	return f.setRawKeys(cmdSet, raw)
 }

features/keys/feature_simulation.go

@@ -8,18 +8,21 @@ import (
 // FeatureSimulation represents simulated keys feature.
 type FeatureSimulation struct {
 	state    *State
+	defaults *device.KeysState
 	template *layout.Template
 }
 
 // NewSimulation creates simulated keys from template.
-func NewSimulation(s *StateData, model device.Model) (*FeatureSimulation, error) {
+func NewSimulation(s *device.KeysState, model device.Model) (*FeatureSimulation, error) {
 	var (
 		f   FeatureSimulation
 		err error
 	)
+
+	f.defaults = s
 	f.template = layout.GetKeystrokeTemplate(model)
 	if f.template != nil {
-		f.state, err = s.Parse(f.template)
+		f.state, err = ParseState(s, f.template)
 	}
 	if err != nil {
 		return nil, err
@@ -79,23 +82,23 @@ func (f *FeatureSimulation) SetMacros(m Macros) error {
 }
 
 // GetStateData returns current simulated state.
-func (f *FeatureSimulation) GetStateData() (*StateData, error) {
+func (f *FeatureSimulation) GetStateData() (*device.KeysState, error) {
 	if f.template == nil {
-		return &StateData{
+		return &device.KeysState{
 			Mac:    make([]byte, 1024),
 			Win:    make([]byte, 1024),
 			Macros: make([]byte, 1024),
 		}, nil
 	}
-	return f.state.Data(f.template)
+	return f.state.Data(f.template, f.defaults)
 }
 
 // SetStateData sets current simulated state.
-func (f *FeatureSimulation) SetStateData(s *StateData) error {
+func (f *FeatureSimulation) SetStateData(s *device.KeysState) error {
 	if f.template == nil {
 		return ErrNoTemplate
 	}
-	state, err := s.Parse(f.template)
+	state, err := ParseState(s, f.template)
 	if err != nil {
 		return err
 	}

features/keys/keycode.go

@@ -20,10 +20,15 @@ func UnpackKeyCodes(v []uint32) []byte {
 	var offset int
 	for i := 0; i < len(v); i++ {
 		offset = (i * 4)
-		payload[offset] = byte(v[i] & 0xFF)
-		payload[offset+1] = byte((v[i] >> 8) & 0xFF)
-		payload[offset+2] = byte((v[i] >> 16) & 0xFF)
-		payload[offset+3] = byte((v[i] >> 24) & 0xFF)
+		UnpackKeyCode(v[i], payload[offset:offset+4])
 	}
 	return payload
 }
+
+// UnpackKeyCode unpacks key code to target slice
+func UnpackKeyCode(v uint32, target []byte) {
+	target[0] = byte(v & 0xFF)
+	target[1] = byte((v >> 8) & 0xFF)
+	target[2] = byte((v >> 16) & 0xFF)
+	target[3] = byte((v >> 24) & 0xFF)
+}

features/keys/keycode_test.go

@@ -15,7 +15,6 @@ var keyCodes = []uint32{
 func TestPackKeyCodes(t *testing.T) {
 	t.Parallel()
 	result := PackKeyCodes(rawBytes)
-	// Check some random values
 	for i, v := range keyCodes {
 		if result[i] != v {
 			t.Errorf("result[%d] = %02x, want %02x", i, result[i], v)

features/keys/keymap.go

@@ -1,6 +1,8 @@
 package keys
 
-import "github.com/mishamyrt/nuga-lib/layout"
+import (
+	"github.com/mishamyrt/nuga-lib/layout"
+)
 
 // ActionType represents action type
 type ActionType string
@@ -30,24 +32,34 @@ type Key struct {
 // KeyMap represents keyboard layout
 type KeyMap map[layout.KeyName]Key
 
+func (k KeyMap) SetKey(name layout.KeyName, value Key) error {
+	if _, ok := k[name]; !ok {
+		return ErrKeyNotFound
+	}
+	k[name] = value
+	return nil
+}
+
 // Bytes returns key map as bytes
-func (k KeyMap) Bytes(tpl *layout.Template) []byte {
-	codes := make([]uint32, 256)
+func (k KeyMap) Bytes(tpl *layout.Template, defaults []byte) []byte {
+	raw := make([]byte, len(defaults))
+	copy(raw, defaults)
 	for keyName, v := range k {
+		var code uint32
 		position := tpl.GetPosition(keyName)
 		switch v.Type {
 		case ActionKeystroke:
-			codes[position] = layout.FindKeyCode(v.Keystroke.Name)
-			if IsRegularKey(codes[position]) && v.Keystroke.Modifiers != nil {
-				codes[position] = ApplyModifiers(codes[position], v.Keystroke.Modifiers)
+			code = layout.FindKeyCode(v.Keystroke.Name)
+			if IsRegularKey(code) && v.Keystroke.Modifiers != nil {
+				code = ApplyModifiers(code, v.Keystroke.Modifiers)
 			}
 		case ActionMacro:
-			codes[position] = IndexToMacro(*v.MacroIndex)
-		case ActionNone:
-			codes[position] = 0
+			code = IndexToMacro(*v.MacroIndex)
 		}
+		rawPosition := position * 4
+		UnpackKeyCode(code, raw[rawPosition:rawPosition+4])
 	}
-	return UnpackKeyCodes(codes)
+	return raw
 }
 
 // ParseKeyMap key map from values

features/keys/keymap_test.go

@@ -64,7 +64,8 @@ func TestBytes(t *testing.T) {
 		{layout.KeyY, keys.IndexToMacro(1)},
 		{layout.KeyR, layout.Keys[layout.KeyNone].Code},
 	}
-	raw := testKeyMap.Bytes(&testTemplate)
+	defaultsMock := make([]byte, len(tests)*4)
+	raw := testKeyMap.Bytes(&testTemplate, defaultsMock)
 	codes := keys.PackKeyCodes(raw)
 
 	if len(codes) < len(testTemplate) {

features/simulation.go

@@ -7,19 +7,13 @@ import (
 	"github.com/pkg/errors"
 )
 
-// StateData represents raw features state. It contains data of all supported features
-type StateData struct {
-	Lights *light.StateData `json:"lights"`
-	Keys   *keys.StateData  `json:"keys"`
-}
-
 // NewSimulation creates simulated features from state
-func NewSimulation(s *StateData, model device.Model) (*Features, error) {
-	l, err := light.NewSimulation(s.Lights, model)
+func NewSimulation(s *device.State) (*Features, error) {
+	l, err := light.NewSimulation(s.Data.Lights, s.Model)
 	if err != nil {
 		return nil, errors.Wrap(err, "lights")
 	}
-	k, err := keys.NewSimulation(s.Keys, model)
+	k, err := keys.NewSimulation(s.Data.Keys, s.Model)
 	if err != nil {
 		return nil, errors.Wrap(err, "keys")
 	}