SET_REPORT and GET_REPORT implemented

bumble/hid.py

@@ -313,10 +313,10 @@ class HID(EventEmitter):
             self.handle_set_report(pdu)
         elif message_type == Message.MessageType.GET_PROTOCOL:
             logger.debug('<<< HID GET PROTOCOL')
-            self.emit('get_protocol')
+            self.handle_get_protocol(pdu)
         elif message_type == Message.MessageType.SET_PROTOCOL:
             logger.debug('<<< HID SET PROTOCOL')
-            self.emit('set_protocol', param)
+            self.handle_set_protocol(pdu)
         elif message_type == Message.MessageType.DATA:
             logger.debug('<<< HID CONTROL DATA')
             self.emit('control_data', pdu)
@@ -426,6 +426,7 @@ class Device(HID):
                 self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
         else:
           logger.debug("GetReport callback not registered !!")
+          self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
           
     def register_get_report_cb(self,cb):
         self.get_report_cb=cb
@@ -439,13 +440,48 @@ class Device(HID):
             ret = self.set_report_cb(report_id, report_type, report_data)
             if(ret.status == self.ReportStatus.SUCCESS):
                 self.send_handshake_message(Message.Handshake.SUCCESSFUL)
+                return
         else:
-                self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)
+            logger.debug("SetReport callback not registered !!")
+        
+        self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
             
     def register_set_report_cb(self, cb):
         self.set_report_cb=cb
         logger.debug("SetReport callback registered successfully")
         
+    def handle_get_protocol(self, pdu: bytes):
+        ret = self.GetReportStatus()
+        if(self.get_protocol_cb != None):
+            ret=self.get_protocol_cb()
+            if(ret.status == self.ReportStatus.SUCCESS):
+                self.send_control_data(Message.ReportType.OTHER_REPORT, ret.data)
+                return
+        else:
+            logger.debug("GetProtocol callback not registered !!")
+
+        self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
+
+    def register_get_protocol_cb(self, cb):
+        self.get_protocol_cb=cb
+        logger.debug("GetProtocol callback registered successfully")
+    
+    def handle_set_protocol(self, pdu: bytes):
+        ret = self.GetReportStatus()
+        if(self.set_protocol_cb != None):
+            ret=self.set_protocol_cb(pdu[0] & 0x01)
+            if(ret.status == self.ReportStatus.SUCCESS):
+                return
+        else:
+            logger.debug("SetProtocol callback not registered !!")
+            
+        self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
+        
+    
+    def register_set_protocol_cb(self, cb):
+        self.set_protocol_cb=cb
+        logger.debug("SetProtocol callback registered successfully")
+
 # -----------------------------------------------------------------------------
 class Host(HID):
     def __init__(self, device: Device) -> None:

examples/run_hid_device.py

@@ -502,22 +502,6 @@ async def main():
     def on_hid_data_cb(pdu):
         print(f'Received Data, PDU: {pdu.hex()}')
 
-    def on_set_report_cb(report_id: int, report: bytes):
-        if (report_id > 2) or (report_id == 0):
-            hid_device.send_handshake_message(Message.Handshake.ERR_INVALID_REPORT_ID)
-            print("Warning: Report ID Not Supported")
-        else:
-            hid_device.send_handshake_message(Message.Handshake.SUCCESSFUL)
-            print('Set Report, Report ID: ', report_id)
-            print('Report:', report)
-
-    def on_get_protocol_cb():
-            if HID_BOOT_DEVICE:
-                data = protocol_mode.to_bytes()
-                hid_device.send_control_data(Message.ReportType.OTHER_REPORT, data)
-            else:
-                hid_device.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-                
     def on_get_report_cb(report_id,report_type, buffer_size):
         retValue = hid_device.GetReportStatus()
         print("GET_REPORT report_id: " + str(report_id) +"report_type: "+ str(report_type)+ 
@@ -558,13 +542,18 @@ async def main():
         return retValue
         
 
-    def on_set_protocol_cb(param):
+    def on_get_protocol_cb():
-        if HID_BOOT_DEVICE:
+        retValue = hid_device.GetReportStatus()
-            global protocol_mode
+        retValue.data=protocol_mode.to_bytes()
-            protocol_mode = Message.ProtocolMode(param)
+        retValue.status=hid_device.ReportStatus.SUCCESS
-            hid_device.send_handshake_message(Message.Handshake.SUCCESSFUL)
+        return retValue
-        else:
+
-            hid_device.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
+    def on_set_protocol_cb(protocol):
+        retValue = hid_device.GetReportStatus()
+        #We do not support SET_PROTOCOL
+        print("SET_PROTOCOL report_id: " + str(protocol))
+        retValue.status=hid_device.ReportStatus.ERR_UNSUPPORTED_REQUEST
+        return retValue
 
     def on_virtual_cable_unplug_cb():
         print(f'Received Virtual Cable Unplug')
@@ -583,11 +572,11 @@ async def main():
 
         # Register for  call backs
         hid_device.on('interrupt_data', on_hid_data_cb)
-        hid_device.on('get_protocol', on_get_protocol_cb)
-        hid_device.on('set_protocol', on_set_protocol_cb)
         
         hid_device.register_get_report_cb(on_get_report_cb)
         hid_device.register_set_report_cb(on_set_report_cb)
+        hid_device.register_get_protocol_cb(on_get_protocol_cb)
+        hid_device.register_set_protocol_cb(on_set_protocol_cb)
 
         # Register for virtual cable unplug call back
         hid_device.on('virtual_cable_unplug', on_virtual_cable_unplug_cb)