finished media key support

Author: sidit77

inputshare-client/src/main.rs

@@ -268,7 +268,10 @@ impl<'a> InputTransmitter<'a> {
                                     KeyState::Released => sender.release_key(kc)
                                 },
                                 None => match wsc_to_cdc(sc){
-                                    Some(cdc) => println!("{:?}", cdc),
+                                    Some(cdc) => match ks {
+                                        KeyState::Pressed => sender.press_consumer_device(cdc),
+                                        KeyState::Released => sender.release_consumer_device(cdc)
+                                    },
                                     None => if! matches!(sc, 0x21d) {
                                         println!("Unknown key: {} ({:x})", vk, sc)
                                     }

inputshare-client/src/sender.rs

@@ -1,5 +1,5 @@
 use std::collections::VecDeque;
-use inputshare_common::{HidButtonCode, HidKeyCode, MessageType, MouseType, Vec2};
+use inputshare_common::{ConsumerDeviceCode, HidButtonCode, HidKeyCode, MessageType, MouseType, Vec2};
 use std::io::{Result, Write};
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 
@@ -61,6 +61,14 @@ impl InputSender {
         self.message_queue.push_back([MessageType::MouseButtonRelease.into(), button.into()])
     }
 
+    pub fn press_consumer_device(&mut self, button: ConsumerDeviceCode) {
+        self.message_queue.push_back([MessageType::ConsumerDevicePress.into(), button.into()])
+    }
+
+    pub fn release_consumer_device(&mut self, button: ConsumerDeviceCode) {
+        self.message_queue.push_back([MessageType::ConsumerDeviceRelease.into(), button.into()])
+    }
+
     pub fn scroll_horizontal(&mut self, amount: i8) {
         self.message_queue.push_back([MessageType::HorizontalScrolling.into(), amount as u8])
     }

inputshare-server/src/main.rs

@@ -15,7 +15,7 @@ use mio::net::UdpSocket;
 use mio_signals::{Signal, Signals, SignalSet};
 use udp_connections::{MAX_PACKET_SIZE, Server, ServerEvent, Transport};
 use vec_map::VecMap;
-use inputshare_common::{HidButtonCode, HidKeyCode, IDENTIFIER};
+use inputshare_common::{ConsumerDeviceCode, HidButtonCode, HidKeyCode, IDENTIFIER};
 use crate::receiver::{InputEvent, InputReceiver};
 
 /// The server for inputshare
@@ -109,8 +109,6 @@ fn server(args: Args) -> Result<()> {
             }
         }
 
-        consumer_device.press_key(1 << 5)?;
-        consumer_device.release_key(1 << 5)?;
         socket.update();
         loop {
             match socket.next_event(&mut buffer) {
@@ -138,6 +136,8 @@ fn server(args: Args) -> Result<()> {
                                     InputEvent::KeyRelease(key) => keyboard.release_key(key)?,
                                     InputEvent::MouseButtonPress(button) => mouse.press_button(button)?,
                                     InputEvent::MouseButtonRelease(button) => mouse.release_button(button)?,
+                                    InputEvent::ConsumerDevicePress(button) => consumer_device.press_key(button)?,
+                                    InputEvent::ConsumerDeviceRelease(button) => consumer_device.release_key(button)?,
                                     InputEvent::HorizontalScrolling(amount) => mouse.scroll_horizontal(amount)?,
                                     InputEvent::VerticalScrolling(amount) => mouse.scroll_vertical(amount)?,
                                     InputEvent::Reset => {
@@ -260,7 +260,7 @@ impl Keyboard {
 #[derive(Debug)]
 pub struct ConsumerDevice {
     device: File,
-    pressed_keys: u16,
+    pressed_keys: ConsumerDeviceButtons,
 }
 
 impl ConsumerDevice {
@@ -269,27 +269,37 @@ impl ConsumerDevice {
         let device = OpenOptions::new().write(true).append(true).open("/dev/hidg2")?;
         Ok(Self {
             device,
-            pressed_keys: 0
+            pressed_keys: ConsumerDeviceButtons::empty()
         })
     }
 
     fn send_report(&mut self) -> std::io::Result<()> {
-        self.device.write_all(&self.pressed_keys.to_le_bytes())
+        self.device.write_all(&self.pressed_keys.bits().to_le_bytes())
     }
 
     pub fn reset(&mut self) -> std::io::Result<()> {
-        self.pressed_keys = 0;
+        self.pressed_keys = ConsumerDeviceButtons::empty();
         self.send_report()
     }
 
-    pub fn press_key(&mut self, key: u16) -> std::io::Result<()> {
-        self.pressed_keys |= key;
-        self.send_report()
+    pub fn press_key(&mut self, key: ConsumerDeviceCode) -> std::io::Result<()> {
+        match key.try_into() {
+            Ok(key) => {
+                self.pressed_keys.insert(key);
+                self.send_report()
+            },
+            Err(()) => Ok(())
+        }
     }
 
-    pub fn release_key(&mut self, key: u16) -> std::io::Result<()> {
-        self.pressed_keys &= !key;
-        self.send_report()
+    pub fn release_key(&mut self, key: ConsumerDeviceCode) -> std::io::Result<()> {
+        match key.try_into() {
+            Ok(key) => {
+                self.pressed_keys.remove(key);
+                self.send_report()
+            },
+            Err(()) => Ok(())
+        }
     }
 
 }
@@ -388,7 +398,7 @@ fn abs_min(a: i16, b: i16) -> i16 {
     }
 }
 
-pub use flags::{HidMouseButtons, HidModifierKeys};
+pub use flags::{HidMouseButtons, HidModifierKeys, ConsumerDeviceButtons};
 
 #[allow(non_upper_case_globals)]
 pub mod flags {
@@ -412,6 +422,51 @@ pub mod flags {
             const Button4 = 0x08;
             const Button5 = 0x10;
         }
+
+        pub struct ConsumerDeviceButtons: u16 {
+            const NextTrack        = 0x0001;
+            const PreviousTrack    = 0x0002;
+            const Stop             = 0x0004;
+            const PlayPause        = 0x0008;
+            const Mute             = 0x0010;
+            const VolumeUp         = 0x0020;
+            const VolumeDown       = 0x0040;
+            const BrowserHome      = 0x0080;
+            const MyComputer       = 0x0100;
+            const Calculator       = 0x0200;
+            const BrowserFavorites = 0x0400;
+            const BrowserSearch    = 0x0800;
+            const BrowserStop      = 0x1000;
+            const BrowserBack      = 0x2000;
+            const MediaSelect      = 0x4000;
+            const Mail             = 0x8000;
+        }
+    }
+}
+
+impl TryFrom<ConsumerDeviceCode> for ConsumerDeviceButtons {
+    type Error = ();
+
+    fn try_from(value: ConsumerDeviceCode) -> std::result::Result<Self, Self::Error> {
+        match value {
+            ConsumerDeviceCode::NextTrack => Ok(ConsumerDeviceButtons::NextTrack),
+            ConsumerDeviceCode::PreviousTrack => Ok(ConsumerDeviceButtons::PreviousTrack),
+            ConsumerDeviceCode::Stop => Ok(ConsumerDeviceButtons::Stop),
+            ConsumerDeviceCode::PlayPause => Ok(ConsumerDeviceButtons::PlayPause),
+            ConsumerDeviceCode::Mute => Ok(ConsumerDeviceButtons::Mute),
+            ConsumerDeviceCode::VolumeUp => Ok(ConsumerDeviceButtons::VolumeUp),
+            ConsumerDeviceCode::VolumeDown => Ok(ConsumerDeviceButtons::VolumeDown),
+            ConsumerDeviceCode::MediaSelect => Ok(ConsumerDeviceButtons::MediaSelect),
+            ConsumerDeviceCode::Mail => Ok(ConsumerDeviceButtons::Mail),
+            ConsumerDeviceCode::Calculator => Ok(ConsumerDeviceButtons::Calculator),
+            ConsumerDeviceCode::MyComputer => Ok(ConsumerDeviceButtons::MyComputer),
+            ConsumerDeviceCode::BrowserSearch => Ok(ConsumerDeviceButtons::BrowserSearch),
+            ConsumerDeviceCode::BrowserHome => Ok(ConsumerDeviceButtons::BrowserHome),
+            ConsumerDeviceCode::BrowserBack => Ok(ConsumerDeviceButtons::BrowserBack),
+            ConsumerDeviceCode::BrowserStop => Ok(ConsumerDeviceButtons::BrowserStop),
+            ConsumerDeviceCode::BrowserFavorites => Ok(ConsumerDeviceButtons::BrowserFavorites),
+            _ => Err(())
+        }
     }
 }
 

inputshare-server/src/receiver.rs

@@ -1,6 +1,6 @@
 use std::collections::VecDeque;
 use std::convert::TryFrom;
-use inputshare_common::{HidButtonCode, HidKeyCode, MessageType, MouseType, Vec2};
+use inputshare_common::{ConsumerDeviceCode, HidButtonCode, HidKeyCode, MessageType, MouseType, Vec2};
 use std::io::Result;
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 
@@ -11,6 +11,8 @@ pub enum InputEvent {
     KeyRelease(HidKeyCode),
     MouseButtonPress(HidButtonCode),
     MouseButtonRelease(HidButtonCode),
+    ConsumerDevicePress(ConsumerDeviceCode),
+    ConsumerDeviceRelease(ConsumerDeviceCode),
     HorizontalScrolling(i8),
     VerticalScrolling(i8),
     Reset,
@@ -63,6 +65,8 @@ impl InputReceiver {
                 Ok(MessageType::KeyRelease) => self.events.push_back(InputEvent::KeyRelease(HidKeyCode::from(msg_arg))),
                 Ok(MessageType::MouseButtonPress) => self.events.push_back(InputEvent::MouseButtonPress(HidButtonCode::from(msg_arg))),
                 Ok(MessageType::MouseButtonRelease) => self.events.push_back(InputEvent::MouseButtonRelease(HidButtonCode::from(msg_arg))),
+                Ok(MessageType::ConsumerDevicePress) => self.events.push_back(InputEvent::ConsumerDevicePress(ConsumerDeviceCode::from(msg_arg))),
+                Ok(MessageType::ConsumerDeviceRelease) => self.events.push_back(InputEvent::ConsumerDeviceRelease(ConsumerDeviceCode::from(msg_arg))),
                 Ok(MessageType::HorizontalScrolling) => self.events.push_back(InputEvent::HorizontalScrolling(msg_arg as i8)),
                 Ok(MessageType::VerticalScrolling) => self.events.push_back(InputEvent::VerticalScrolling(msg_arg as i8)),
                 Ok(MessageType::Reset) => self.events.push_back(InputEvent::Reset),

lib/inputshare-common/src/lib.rs

@@ -24,6 +24,8 @@ pub enum MessageType {
     KeyRelease,
     MouseButtonPress,
     MouseButtonRelease,
+    ConsumerDevicePress,
+    ConsumerDeviceRelease,
     HorizontalScrolling,
     VerticalScrolling,
     Reset
@@ -42,34 +44,34 @@ pub enum HidButtonCode {
 }
 
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, IntoPrimitive, FromPrimitive)]
-#[repr(u16)]
+#[repr(u8)]
 pub enum ConsumerDeviceCode {
     #[num_enum(default)]
     None = 0x00,
-    NextTrack = 0x00b5,
-    PreviousTrack = 0x00b6,
-    Stop = 0x00b7,
-    PlayPause = 0x00cd,
-    Mute = 0x00e2,
-    BassBoost = 0x00e5,
-    Loudness = 0x00e7,
-    VolumeUp = 0x00e9,
-    VolumeDown = 0x00ea,
-    BassUp = 0x0152,
-    BassDown = 0x0153,
-    TrebleUp = 0x0154,
-    TrebleDown = 0x0155,
-    MediaSelect = 0x0183,
-    Mail = 0x018a,
-    Calculator = 0x0192,
-    MyComputer = 0x0194,
-    BrowserSearch = 0x0221,
-    BrowserHome = 0x0223,
-    BrowserBack = 0x0224,
-    BrowserForward = 0x0225,
-    BrowserStop = 0x0226,
-    BrowserRefresh = 0x0227,
-    BrowserFavorites = 0x022a
+    NextTrack,
+    PreviousTrack,
+    Stop,
+    PlayPause,
+    Mute,
+    BassBoost,
+    Loudness,
+    VolumeUp,
+    VolumeDown,
+    BassUp,
+    BassDown,
+    TrebleUp,
+    TrebleDown,
+    MediaSelect,
+    Mail,
+    Calculator,
+    MyComputer,
+    BrowserSearch,
+    BrowserHome,
+    BrowserBack,
+    BrowserForward,
+    BrowserStop,
+    BrowserRefresh,
+    BrowserFavorites
 }
 
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, IntoPrimitive, FromPrimitive)]