Revert "The UHK now only sends out data when it changes"

right/src/usb_interfaces/usb_interface_basic_keyboard.c

@@ -4,6 +4,7 @@
 static usb_basic_keyboard_report_t usbBasicKeyboardReports[2];
 uint32_t UsbBasicKeyboardActionCounter;
 usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
+volatile bool IsUsbBasicKeyboardReportSent = false;
 static uint8_t usbBasicKeyboardInBuffer[USB_BASIC_KEYBOARD_REPORT_LENGTH];
 
 static usb_basic_keyboard_report_t* getInactiveUsbBasicKeyboardReport(void)
@@ -21,12 +22,14 @@ void ResetActiveUsbBasicKeyboardReport(void)
     bzero(ActiveUsbBasicKeyboardReport, USB_BASIC_KEYBOARD_REPORT_LENGTH);
 }
 
-usb_status_t UsbBasicKeyboardAction(void)
+static usb_status_t UsbBasicKeyboardAction(void)
 {
-    UsbBasicKeyboardActionCounter++;
+    usb_status_t status = USB_DeviceHidSend(
-    return USB_DeviceHidSend(
         UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
         (uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
+    IsUsbBasicKeyboardReportSent = true;
+    UsbBasicKeyboardActionCounter++;
+    return status;
 }
 
 usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -35,6 +38,10 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
+            if (UsbCompositeDevice.attach) {
+                return UsbBasicKeyboardAction();
+            }
+            break;
         case kUSB_DeviceHidEventGetReport:
             error = kStatus_USB_InvalidRequest;
             break;
@@ -73,7 +80,7 @@ usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, voi
 usb_status_t UsbBasicKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
     if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        //return UsbBasicKeyboardAction();
+        return UsbBasicKeyboardAction();
     }
     return kStatus_USB_Error;
 }
@@ -81,7 +88,7 @@ usb_status_t UsbBasicKeyboardSetConfiguration(class_handle_t handle, uint8_t con
 usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_BASIC_KEYBOARD_INTERFACE_INDEX == interface) {
-        //return UsbBasicKeyboardAction();
+        return UsbBasicKeyboardAction();
     }
     return kStatus_USB_Error;
 }

right/src/usb_interfaces/usb_interface_basic_keyboard.h

@@ -31,6 +31,7 @@
 
 // Variables:
 
+    extern volatile bool IsUsbBasicKeyboardReportSent;
     extern uint32_t UsbBasicKeyboardActionCounter;
     extern usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport;
 
@@ -42,6 +43,5 @@
 
     void ResetActiveUsbBasicKeyboardReport(void);
     void SwitchActiveUsbBasicKeyboardReport(void);
-    usb_status_t UsbBasicKeyboardAction(void);
 
 #endif

right/src/usb_interfaces/usb_interface_media_keyboard.c

@@ -3,6 +3,7 @@
 uint32_t UsbMediaKeyboardActionCounter;
 static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
 usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
+volatile bool IsUsbMediaKeyboardReportSent = false;
 
 static usb_media_keyboard_report_t* getInactiveUsbMediaKeyboardReport(void)
 {
@@ -19,12 +20,14 @@ void ResetActiveUsbMediaKeyboardReport(void)
     bzero(ActiveUsbMediaKeyboardReport, USB_MEDIA_KEYBOARD_REPORT_LENGTH);
 }
 
-usb_status_t UsbMediaKeyboardAction()
+static usb_status_t UsbMediaKeyboardAction(void)
 {
-    UsbMediaKeyboardActionCounter++;
+    usb_status_t status = USB_DeviceHidSend(
-    return USB_DeviceHidSend(
         UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
         (uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
+    IsUsbMediaKeyboardReportSent = true;
+    UsbMediaKeyboardActionCounter++;
+    return status;
 }
 
 usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -33,6 +36,10 @@ usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, voi
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
+            if (UsbCompositeDevice.attach) {
+                return UsbMediaKeyboardAction();
+            }
+            break;
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:
@@ -53,7 +60,7 @@ usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, voi
 usb_status_t UsbMediaKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
     if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        //return UsbMediaKeyboardAction();
+        return UsbMediaKeyboardAction();
     }
     return kStatus_USB_Error;
 }
@@ -61,7 +68,7 @@ usb_status_t UsbMediaKeyboardSetConfiguration(class_handle_t handle, uint8_t con
 usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_MEDIA_KEYBOARD_INTERFACE_INDEX == interface) {
-        //return UsbMediaKeyboardAction();
+        return UsbMediaKeyboardAction();
     }
     return kStatus_USB_Error;
 }

right/src/usb_interfaces/usb_interface_media_keyboard.h

@@ -28,6 +28,7 @@
 
 // Variables:
 
+    extern volatile bool IsUsbMediaKeyboardReportSent;
     extern uint32_t UsbMediaKeyboardActionCounter;
     extern usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport;
 
@@ -39,6 +40,5 @@
 
     void ResetActiveUsbMediaKeyboardReport(void);
     void SwitchActiveUsbMediaKeyboardReport(void);
-    usb_status_t UsbMediaKeyboardAction();
 
 #endif

right/src/usb_interfaces/usb_interface_mouse.c

@@ -3,6 +3,7 @@
 uint32_t UsbMouseActionCounter;
 static usb_mouse_report_t usbMouseReports[2];
 usb_mouse_report_t* ActiveUsbMouseReport = usbMouseReports;
+volatile bool IsUsbMouseReportSent = false;
 
 static usb_mouse_report_t* getInactiveUsbMouseReport(void)
 {
@@ -19,31 +20,25 @@ void ResetActiveUsbMouseReport(void)
     bzero(ActiveUsbMouseReport, USB_MOUSE_REPORT_LENGTH);
 }
 
-usb_status_t usbMouseAction(void)
+static volatile usb_status_t usbMouseAction(void)
 {
-    UsbMouseActionCounter++;
+    usb_mouse_report_t *mouseReport = getInactiveUsbMouseReport();
-    return USB_DeviceHidSend(
+    IsUsbMouseReportSent = true;
-            UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
+    return USB_DeviceHidSend(UsbCompositeDevice.mouseHandle, USB_MOUSE_ENDPOINT_INDEX,
-            (uint8_t*)getInactiveUsbMouseReport(), USB_MOUSE_REPORT_LENGTH);
+               (uint8_t*)mouseReport, USB_MOUSE_REPORT_LENGTH);
 }
 
 usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param)
 {
-    static bool usbMouseActionActive = false;
+    UsbMouseActionCounter++;
     usb_status_t error = kStatus_USB_Error;
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
             if (UsbCompositeDevice.attach) {
-                // Send out the report continuously if the report is not zeros
-                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) {
-                    usbMouseActionActive = reportChanged; // Used to send out all zeros once after a report has been sent
                 return usbMouseAction();
             }
-            }
+            break;
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:
@@ -64,7 +59,7 @@ usb_status_t UsbMouseCallback(class_handle_t handle, uint32_t event, void *param
 usb_status_t UsbMouseSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
     if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        //return usbMouseAction();
+        return usbMouseAction();
     }
     return kStatus_USB_Error;
 }
@@ -72,7 +67,7 @@ usb_status_t UsbMouseSetConfiguration(class_handle_t handle, uint8_t configurati
 usb_status_t UsbMouseSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_MOUSE_INTERFACE_INDEX == interface) {
-        //return usbMouseAction();
+        return usbMouseAction();
     }
     return kStatus_USB_Error;
 }

right/src/usb_interfaces/usb_interface_mouse.h

@@ -31,6 +31,7 @@
 
 // Variables:
 
+    extern volatile bool IsUsbMouseReportSent;
     extern uint32_t UsbMouseActionCounter;
     extern usb_mouse_report_t* ActiveUsbMouseReport;
 
@@ -42,6 +43,5 @@
 
     void ResetActiveUsbMouseReport(void);
     void SwitchActiveUsbMouseReport(void);
-    usb_status_t usbMouseAction(void);
 
 #endif

right/src/usb_interfaces/usb_interface_system_keyboard.c

@@ -3,6 +3,7 @@
 uint32_t UsbSystemKeyboardActionCounter;
 static usb_system_keyboard_report_t usbSystemKeyboardReports[2];
 usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport = usbSystemKeyboardReports;
+volatile bool IsUsbSystemKeyboardReportSent = false;
 
 static usb_system_keyboard_report_t* getInactiveUsbSystemKeyboardReport()
 {
@@ -19,12 +20,14 @@ void ResetActiveUsbSystemKeyboardReport(void)
     bzero(ActiveUsbSystemKeyboardReport, USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
 }
 
-usb_status_t UsbSystemKeyboardAction(void)
+static usb_status_t UsbSystemKeyboardAction(void)
 {
-    UsbSystemKeyboardActionCounter++;
+    usb_status_t status = USB_DeviceHidSend(
-    return USB_DeviceHidSend(
         UsbCompositeDevice.systemKeyboardHandle, USB_SYSTEM_KEYBOARD_ENDPOINT_INDEX,
         (uint8_t*)getInactiveUsbSystemKeyboardReport(), USB_SYSTEM_KEYBOARD_REPORT_LENGTH);
+    IsUsbSystemKeyboardReportSent = true;
+    UsbSystemKeyboardActionCounter++;
+    return status;
 }
 
 usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
@@ -33,6 +36,10 @@ usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, vo
 
     switch (event) {
         case kUSB_DeviceHidEventSendResponse:
+            if (UsbCompositeDevice.attach) {
+                return UsbSystemKeyboardAction();
+            }
+            break;
         case kUSB_DeviceHidEventGetReport:
         case kUSB_DeviceHidEventSetReport:
         case kUSB_DeviceHidEventRequestReportBuffer:
@@ -53,7 +60,7 @@ usb_status_t UsbSystemKeyboardCallback(class_handle_t handle, uint32_t event, vo
 usb_status_t UsbSystemKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
 {
     if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        //return UsbSystemKeyboardAction();
+        return UsbSystemKeyboardAction();
     }
     return kStatus_USB_Error;
 }
@@ -61,7 +68,7 @@ usb_status_t UsbSystemKeyboardSetConfiguration(class_handle_t handle, uint8_t co
 usb_status_t UsbSystemKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
 {
     if (USB_SYSTEM_KEYBOARD_INTERFACE_INDEX == interface) {
-        //return UsbSystemKeyboardAction();
+        return UsbSystemKeyboardAction();
     }
     return kStatus_USB_Error;
 }

right/src/usb_interfaces/usb_interface_system_keyboard.h

@@ -29,6 +29,7 @@
 
 // Variables:
 
+    extern volatile bool IsUsbSystemKeyboardReportSent;
     extern uint32_t UsbSystemKeyboardActionCounter;
     extern usb_system_keyboard_report_t* ActiveUsbSystemKeyboardReport;
 
@@ -40,6 +41,5 @@
 
     void ResetActiveUsbSystemKeyboardReport(void);
     void SwitchActiveUsbSystemKeyboardReport(void);
-    usb_status_t UsbSystemKeyboardAction(void);
 
 #endif

right/src/usb_report_updater.c

@@ -408,6 +408,8 @@ void UpdateUsbReports(void)
             return;
         }
         Timer_SetCurrentTime(&lastMouseUpdateTime);
+    } else if (!IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) {
+        return;
     }
 
     ResetActiveUsbBasicKeyboardReport();
@@ -418,42 +420,34 @@ 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) {
         last_basic_report = *ActiveUsbBasicKeyboardReport;
         SwitchActiveUsbBasicKeyboardReport();
-        HasUsbBasicKeyboardReportChanged = true;
+        IsUsbBasicKeyboardReportSent = false;
-        UsbBasicKeyboardAction();
     }
 
     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) {
         last_media_report = *ActiveUsbMediaKeyboardReport;
-        HasUsbMediaKeyboardReportChanged = true;
         SwitchActiveUsbMediaKeyboardReport();
-        UsbMediaKeyboardAction();
+        IsUsbMediaKeyboardReportSent = false;
     }
 
     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) {
         last_system_report = *ActiveUsbSystemKeyboardReport;
-        HasUsbSystemKeyboardReportChanged = true;
         SwitchActiveUsbSystemKeyboardReport();
-        UsbSystemKeyboardAction();
+        IsUsbSystemKeyboardReportSent = false;
     }
 
     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) {
         last_mouse_report = *ActiveUsbMouseReport;
-        HasUsbMouseReportChanged = true;
         SwitchActiveUsbMouseReport();
-        usbMouseAction();
+        IsUsbMouseReportSent = false;
     }
 
-    if ((previousLayer != LayerId_Base || HasUsbBasicKeyboardReportChanged || HasUsbMediaKeyboardReportChanged || HasUsbSystemKeyboardReportChanged || HasUsbMouseReportChanged) && IsHostSleeping) {
+    if ((previousLayer != LayerId_Base || !IsUsbBasicKeyboardReportSent || !IsUsbMediaKeyboardReportSent || !IsUsbSystemKeyboardReportSent || !IsUsbMouseReportSent) && IsHostSleeping) {
         WakeUpHost(true); // Wake up the host if any key is pressed and the computer is sleeping.
     }
 }