Just compare the active report with the inactive report stored in each interface driver

right/src/usb_interfaces/usb_interface_basic_keyboard.c

@@ -6,14 +6,14 @@ uint32_t UsbBasicKeyboardActionCounter;
 usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
 static uint8_t usbBasicKeyboardInBuffer[USB_BASIC_KEYBOARD_REPORT_LENGTH];
 
-static usb_basic_keyboard_report_t* getInactiveUsbBasicKeyboardReport(void)
+usb_basic_keyboard_report_t* GetInactiveUsbBasicKeyboardReport(void)
 {
     return ActiveUsbBasicKeyboardReport == usbBasicKeyboardReports ? usbBasicKeyboardReports+1 : usbBasicKeyboardReports;
 }
 
-void SwitchActiveUsbBasicKeyboardReport(void)
+static void SwitchActiveUsbBasicKeyboardReport(void)
 {
-    ActiveUsbBasicKeyboardReport = getInactiveUsbBasicKeyboardReport();
+    ActiveUsbBasicKeyboardReport = GetInactiveUsbBasicKeyboardReport();
 }
 
 void ResetActiveUsbBasicKeyboardReport(void)
@@ -24,9 +24,12 @@ void ResetActiveUsbBasicKeyboardReport(void)
 usb_status_t UsbBasicKeyboardAction(void)
 {
     UsbBasicKeyboardActionCounter++;
-    return USB_DeviceHidSend(
+    usb_status_t usb_status = USB_DeviceHidSend(
             UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
-            (uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
+            (uint8_t*)ActiveUsbBasicKeyboardReport, USB_BASIC_KEYBOARD_REPORT_LENGTH);
+    if (usb_status == kStatus_USB_Success)
+        SwitchActiveUsbBasicKeyboardReport(); // Switch the active report if the data was sent successfully
+    return usb_status;
 }
 
 usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, void *param)

right/src/usb_interfaces/usb_interface_basic_keyboard.h

@@ -41,7 +41,7 @@
     usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
 
     void ResetActiveUsbBasicKeyboardReport(void);
-    void SwitchActiveUsbBasicKeyboardReport(void);
+    usb_basic_keyboard_report_t* GetInactiveUsbBasicKeyboardReport(void);
     usb_status_t UsbBasicKeyboardAction(void);
 
 #endif

right/src/usb_interfaces/usb_interface_media_keyboard.c

@@ -4,14 +4,14 @@ uint32_t UsbMediaKeyboardActionCounter;
 static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
 usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
 
-static usb_media_keyboard_report_t* getInactiveUsbMediaKeyboardReport(void)
+usb_media_keyboard_report_t* GetInactiveUsbMediaKeyboardReport(void)
 {
     return ActiveUsbMediaKeyboardReport == usbMediaKeyboardReports ? usbMediaKeyboardReports+1 : usbMediaKeyboardReports;
 }
 
-void SwitchActiveUsbMediaKeyboardReport(void)
+static void SwitchActiveUsbMediaKeyboardReport(void)
 {
-    ActiveUsbMediaKeyboardReport = getInactiveUsbMediaKeyboardReport();
+    ActiveUsbMediaKeyboardReport = GetInactiveUsbMediaKeyboardReport();
 }
 
 void ResetActiveUsbMediaKeyboardReport(void)
@@ -22,9 +22,12 @@ void ResetActiveUsbMediaKeyboardReport(void)
 usb_status_t UsbMediaKeyboardAction()
 {
     UsbMediaKeyboardActionCounter++;
-    return USB_DeviceHidSend(
+    usb_status_t usb_status = USB_DeviceHidSend(
             UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
-            (uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
+            (uint8_t*)ActiveUsbMediaKeyboardReport, USB_MEDIA_KEYBOARD_REPORT_LENGTH);
+    if (usb_status == kStatus_USB_Success)
+        SwitchActiveUsbMediaKeyboardReport(); // Switch the active report if the data was sent successfully
+    return usb_status;
 }
 
 usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, void *param)

right/src/usb_interfaces/usb_interface_media_keyboard.h

@@ -38,7 +38,7 @@
     usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
 
     void ResetActiveUsbMediaKeyboardReport(void);
-    void SwitchActiveUsbMediaKeyboardReport(void);
+    usb_media_keyboard_report_t* GetInactiveUsbMediaKeyboardReport(void);
     usb_status_t UsbMediaKeyboardAction();
 
 #endif

right/src/usb_interfaces/usb_interface_mouse.c

@@ -4,14 +4,14 @@ uint32_t UsbMouseActionCounter;
 static usb_mouse_report_t usbMouseReports[2];
 usb_mouse_report_t* ActiveUsbMouseReport = usbMouseReports;
 
-static usb_mouse_report_t* getInactiveUsbMouseReport(void)
+usb_mouse_report_t* GetInactiveUsbMouseReport(void)
 {
     return ActiveUsbMouseReport == usbMouseReports ? usbMouseReports+1 : usbMouseReports;
 }
 
-void SwitchActiveUsbMouseReport(void)
+static void SwitchActiveUsbMouseReport(void)
 {
-    ActiveUsbMouseReport = getInactiveUsbMouseReport();
+    ActiveUsbMouseReport = GetInactiveUsbMouseReport();
 }
 
 void ResetActiveUsbMouseReport(void)
@@ -22,9 +22,12 @@ void ResetActiveUsbMouseReport(void)
 usb_status_t usbMouseAction(void)
 {
     UsbMouseActionCounter++;
-    return USB_DeviceHidSend(
+    usb_status_t usb_status = USB_DeviceHidSend(
             UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
-            (uint8_t*)getInactiveUsbMouseReport(), USB_MOUSE_REPORT_LENGTH);
+            (uint8_t*)ActiveUsbMouseReport, USB_MOUSE_REPORT_LENGTH);
+    if (usb_status == kStatus_USB_Success)
+        SwitchActiveUsbMouseReport(); // Switch the active report if the data was sent successfully
+    return usb_status;
 }
 
 usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
@@ -35,8 +38,8 @@ usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
             if (UsbCompositeDevice.attach) {
-                // Send out the report continuously if the report is not zeros
+                // Send out the last report continuously if the report was not zeros
-                usb_mouse_report_t *report = getInactiveUsbMouseReport();
+                usb_mouse_report_t *report = GetInactiveUsbMouseReport();
                 uint8_t zeroBuf[sizeof(usb_mouse_report_t)] = { 0 };
                 bool reportChanged = memcmp(report, zeroBuf, sizeof(usb_mouse_report_t)) != 0;
                 if (usbMouseActionActive || reportChanged) {

right/src/usb_interfaces/usb_interface_mouse.h

@@ -41,7 +41,7 @@
     usb_status_t UsbMouseSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
 
     void ResetActiveUsbMouseReport(void);
-    void SwitchActiveUsbMouseReport(void);
+    usb_mouse_report_t* GetInactiveUsbMouseReport(void);
     usb_status_t usbMouseAction(void);
 
 #endif

right/src/usb_interfaces/usb_interface_system_keyboard.c

@@ -4,14 +4,14 @@ uint32_t UsbSystemKeyboardActionCounter;
 static usb_system_keyboard_report_t usbSystemKeyboardReports[2];
 usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport = usbSystemKeyboardReports;
 
-static usb_system_keyboard_report_t* getInactiveUsbSystemKeyboardReport()
+usb_system_keyboard_report_t* GetInactiveUsbSystemKeyboardReport()
 {
     return ActiveUsbSystemKeyboardReport == usbSystemKeyboardReports ? usbSystemKeyboardReports+1 : usbSystemKeyboardReports;
 }
 
-void SwitchActiveUsbSystemKeyboardReport(void)
+static void SwitchActiveUsbSystemKeyboardReport(void)
 {
-    ActiveUsbSystemKeyboardReport = getInactiveUsbSystemKeyboardReport();
+    ActiveUsbSystemKeyboardReport = GetInactiveUsbSystemKeyboardReport();
 }
 
 void ResetActiveUsbSystemKeyboardReport(void)
@@ -22,9 +22,12 @@ void ResetActiveUsbSystemKeyboardReport(void)
 usb_status_t UsbSystemKeyboardAction(void)
 {
     UsbSystemKeyboardActionCounter++;
-    return USB_DeviceHidSend(
+    usb_status_t usb_status = USB_DeviceHidSend(
             UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
-            (uint8_t*)getInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
+            (uint8_t*)ActiveUsbSystemKeyboardReport, USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
+    if (usb_status == kStatus_USB_Success)
+        SwitchActiveUsbSystemKeyboardReport(); // Switch the active report if the data was sent successfully
+    return usb_status;
 }
 
 usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, void *param)

right/src/usb_interfaces/usb_interface_system_keyboard.h

@@ -39,7 +39,7 @@
     usb_status_t UsbSystemKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
 
     void ResetActiveUsbSystemKeyboardReport(void);
-    void SwitchActiveUsbSystemKeyboardReport(void);
+    usb_system_keyboard_report_t* GetInactiveUsbSystemKeyboardReport();
     usb_status_t UsbSystemKeyboardAction(void);
 
 #endif

right/src/usb_report_updater.c

@@ -408,44 +408,28 @@ void UpdateUsbReports(void)
 
     updateActiveUsbReports();
 
-    static usb_basic_keyboard_report_t last_basic_report = { .scancodes[0] = 0xFF };
     bool HasUsbBasicKeyboardReportChanged = false;
-    if (memcmp(ActiveUsbBasicKeyboardReport, &last_basic_report, sizeof(usb_basic_keyboard_report_t)) != 0) {
+    if (memcmp(ActiveUsbBasicKeyboardReport, GetInactiveUsbBasicKeyboardReport(), sizeof(usb_basic_keyboard_report_t)) != 0) {
-        last_basic_report = *ActiveUsbBasicKeyboardReport;
         HasUsbBasicKeyboardReportChanged = true;
-        SwitchActiveUsbBasicKeyboardReport();
+        UsbBasicKeyboardAction();
-        if (UsbBasicKeyboardAction() != kStatus_USB_Success)
-            last_basic_report.scancodes[0] = 0xFF; // Invalidate the stored report if the command fails
     }
 
-    static usb_media_keyboard_report_t last_media_report = { .scancodes[0] = 0xFF };
     bool HasUsbMediaKeyboardReportChanged = false;
-    if (memcmp(ActiveUsbMediaKeyboardReport, &last_media_report, sizeof(usb_media_keyboard_report_t)) != 0) {
+    if (memcmp(ActiveUsbMediaKeyboardReport, GetInactiveUsbMediaKeyboardReport(), sizeof(usb_media_keyboard_report_t)) != 0) {
-        last_media_report = *ActiveUsbMediaKeyboardReport;
         HasUsbMediaKeyboardReportChanged = true;
-        SwitchActiveUsbMediaKeyboardReport();
+        UsbMediaKeyboardAction();
-        if (UsbMediaKeyboardAction() != kStatus_USB_Success)
-            last_media_report.scancodes[0] = 0xFF; // Invalidate the stored report if the command fails
     }
 
-    static usb_system_keyboard_report_t last_system_report = { .scancodes[0] = 0xFF };
     bool HasUsbSystemKeyboardReportChanged = false;
-    if (memcmp(ActiveUsbSystemKeyboardReport, &last_system_report, sizeof(usb_system_keyboard_report_t)) != 0) {
+    if (memcmp(ActiveUsbSystemKeyboardReport, GetInactiveUsbSystemKeyboardReport(), sizeof(usb_system_keyboard_report_t)) != 0) {
-        last_system_report = *ActiveUsbSystemKeyboardReport;
         HasUsbSystemKeyboardReportChanged = true;
-        SwitchActiveUsbSystemKeyboardReport();
+        UsbSystemKeyboardAction();
-        if (UsbSystemKeyboardAction() != kStatus_USB_Success)
-            last_system_report.scancodes[0] = 0xFF; // Invalidate the stored report if the command fails
     }
 
-    static usb_mouse_report_t last_mouse_report = { .buttons = 0xFF };
     bool HasUsbMouseReportChanged = false;
-    if (memcmp(ActiveUsbMouseReport, &last_mouse_report, sizeof(usb_mouse_report_t)) != 0) {
+    if (memcmp(ActiveUsbMouseReport, GetInactiveUsbMouseReport(), sizeof(usb_mouse_report_t)) != 0) {
-        last_mouse_report = *ActiveUsbMouseReport;
         HasUsbMouseReportChanged = true;
-        SwitchActiveUsbMouseReport();
+        usbMouseAction();
-        if (usbMouseAction() != kStatus_USB_Success)
-            last_mouse_report.buttons = 0xFF; // Invalidate the stored report if the command fails
     }
 
     if ((previousLayer != LayerId_Base || HasUsbBasicKeyboardReportChanged || HasUsbMediaKeyboardReportChanged || HasUsbSystemKeyboardReportChanged || HasUsbMouseReportChanged) && IsHostSleeping) {