Update key mappings data in EEPROM for encoders at flashing key mappings

src/actions/hid.action.ts

@@ -472,7 +472,7 @@ export const hidActionsThunk = {
             console.error(result.cause);
             dispatch(
               NotificationActions.addError(
-                `Flush error: [${pos}] ${result.error!}`,
+                `Flash error: [${pos}] ${result.error!}`,
                 result.cause
               )
             );
@@ -490,6 +490,50 @@ export const hidActionsThunk = {
           return;
         }
       }
+      if (0x0a <= entities.device.viaProtocolVersion) {
+        const encodersRemaps = app.encodersRemaps;
+        for (let layer = 0; layer < encodersRemaps.length; layer++) {
+          const encodersRemap = encodersRemaps[layer];
+          for (const encoderIdString of Object.keys(encodersRemap)) {
+            const encoderId = Number(encoderIdString);
+            const encoderKeymap = encodersRemap[encoderId];
+            let result = await keyboard.updateEncoderKeymap(
+              layer,
+              encoderId,
+              true,
+              encoderKeymap.clockwise.code
+            );
+            if (!result.success) {
+              console.error(result.cause);
+              dispatch(
+                NotificationActions.addError(
+                  `Flash error: [${encoderId}-clockwise] ${result.error!}`,
+                  result.cause
+                )
+              );
+              dispatch(HeaderActions.updateFlashing(false));
+              return;
+            }
+            result = await keyboard.updateEncoderKeymap(
+              layer,
+              encoderId,
+              false,
+              encoderKeymap.counterclockwise.code
+            );
+            if (!result.success) {
+              console.error(result.cause);
+              dispatch(
+                NotificationActions.addError(
+                  `Flash error: [${encoderId}-counterclockwise] ${result.error!}`,
+                  result.cause
+                )
+              );
+              dispatch(HeaderActions.updateFlashing(false));
+              return;
+            }
+          }
+        }
+      }
       const keymaps: IKeymaps[] = await loadKeymap(
         dispatch,
         keyboard,

src/services/hid/Hid.mock.ts

@@ -160,6 +160,16 @@ export const mockIKeyboad: IKeyboard = {
       resolve({ success: true });
     });
   },
+  updateEncoderKeymap(
+    layer: number,
+    encoderId: number,
+    clockwise: boolean,
+    code: number
+  ): Promise<IResult> {
+    return new Promise((resolve) => {
+      resolve({ success: true });
+    });
+  },
   fetchBacklightBrightness: () => {
     return new Promise((resolve) => {
       resolve({ success: true, brightness: 100 });

src/services/hid/Hid.ts

@@ -179,6 +179,12 @@ export interface IKeyboard {
     column: number,
     code: number
   ): Promise<IResult>;
+  updateEncoderKeymap(
+    layer: number,
+    encoderId: number,
+    clockwise: boolean,
+    code: number
+  ): Promise<IResult>;
   fetchBacklightBrightness(): Promise<IFetchBrightnessResult>;
   fetchBacklightEffect(): Promise<IFetchBacklightEffectResult>;
   fetchRGBLightBrightness(): Promise<IFetchBrightnessResult>;

src/services/hid/WebHid.ts

@@ -36,6 +36,7 @@ import {
   DynamicKeymapMacroSetBufferCommand,
   DynamicKeymapReadBufferCommand,
   DynamicKeymapResetCommand,
+  DynamicKeymapSetEncoderCommand,
   DynamicKeymapSetKeycodeCommand,
   GetLayoutOptionsCommand,
   GetProtocolVersionCommand,
@@ -398,6 +399,38 @@ export class Keyboard implements IKeyboard {
     });
   }
 
+  updateEncoderKeymap(
+    layer: number,
+    encoderId: number,
+    clockwise: boolean,
+    code: number
+  ): Promise<IResult> {
+    return new Promise<IResult>((resolve) => {
+      const command = new DynamicKeymapSetEncoderCommand(
+        {
+          layer,
+          encoderId,
+          clockwise,
+          code,
+        },
+        async (result) => {
+          if (result.success) {
+            resolve({
+              success: true,
+            });
+          } else {
+            resolve({
+              success: false,
+              error: result.error,
+              cause: result.cause,
+            });
+          }
+        }
+      );
+      return this.enqueue(command);
+    });
+  }
+
   fetchBacklightBrightness(): Promise<IFetchBrightnessResult> {
     return new Promise<IFetchBrightnessResult>((resolve) => {
       const command = new LightingGetValueCommand(