Expose gamepad rumble errors

examples/gamepad.rs

@@ -1,6 +1,6 @@
 extern crate winit;
 use winit::window::WindowBuilder;
-use winit::event::{ElementState, Event, WindowEvent};
+use winit::event::{Event, WindowEvent};
 use winit::event::device::GamepadEvent;
 use winit::event_loop::{EventLoop, ControlFlow};
 
@@ -12,8 +12,6 @@ fn main() {
         .build(&event_loop)
         .unwrap();
 
-    let mut rumble_left = true;
-
     println!("enumerating gamepads:");
     for gamepad in winit::event::device::GamepadHandle::enumerate(&event_loop) {
         println!("    gamepad {:?}", gamepad);
@@ -24,24 +22,9 @@ fn main() {
     event_loop.run(move |event, _, control_flow| {
         match event {
             Event::GamepadEvent(gamepad_handle, event) => match event {
-                GamepadEvent::Axis{stick: false, ..} |
-                GamepadEvent::Added |
-                GamepadEvent::Removed => println!("[{:?}] {:#?}", gamepad_handle, event),
-                GamepadEvent::Stick{x_value, y_value, ..} if (x_value.powi(2) + y_value.powi(2)).sqrt() >= deadzone => {
-                    println!("[{:?}] {:#?}", gamepad_handle, event);
-                },
-                GamepadEvent::Button{ state, .. } => {
-                    println!("[{:?}] {:#?}", gamepad_handle, event);
-                    match state {
-                        ElementState::Pressed if rumble_left => gamepad_handle.rumble(1.0, 0.0),
-                        ElementState::Pressed                => gamepad_handle.rumble(0.0, 1.0),
-                        ElementState::Released => {
-                            gamepad_handle.rumble(0.0, 0.0);
-                            rumble_left = !rumble_left;
-                        },
-                    }
-                },
-                _ => (),
+                GamepadEvent::Axis{stick: true, ..} => (),
+                GamepadEvent::Stick{x_value, y_value, ..} if (x_value.powi(2) + y_value.powi(2)).sqrt() < deadzone => (),
+                _ => println!("[{:?}] {:#?}", gamepad_handle, event)
             },
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,

examples/gamepad_rumble.rs

@@ -0,0 +1,58 @@
+extern crate winit;
+use winit::event_loop::EventLoop;
+use std::time::Instant;
+
+#[derive(Debug, Clone)]
+enum Rumble {
+    None,
+    Left,
+    Right,
+}
+
+fn main() {
+    let event_loop = EventLoop::new();
+
+    // You should generally use `GamepadEvent::Added/Removed` to detect gamepads, as doing that will
+    // allow you to more easily support gamepad hotswapping. However, we're using `enumerate` here
+    // because it makes this example more concise.
+    let gamepads = winit::event::device::GamepadHandle::enumerate(&event_loop).collect::<Vec<_>>();
+
+    let rumble_patterns = &[
+        (0.5, Rumble::None),
+        (2.0, Rumble::Left),
+        (0.5, Rumble::None),
+        (2.0, Rumble::Right),
+    ];
+    let mut rumble_iter = rumble_patterns.iter().cloned().cycle();
+
+    let mut active_pattern = rumble_iter.next().unwrap();
+    let mut timeout = active_pattern.0;
+    let mut timeout_start = Instant::now();
+
+    event_loop.run(move |_, _, _| {
+        if timeout <= active_pattern.0 {
+            let t = (timeout / active_pattern.0) * std::f64::consts::PI;
+            let intensity = t.sin();
+
+            for g in &gamepads {
+                let result = match active_pattern.1 {
+                    Rumble::Left => g.rumble(intensity, 0.0),
+                    Rumble::Right => g.rumble(0.0, intensity),
+                    Rumble::None => Ok(()),
+                };
+
+                if let Err(e) = result {
+                    println!("Rumble failed: {:?}", e);
+                }
+            }
+
+            timeout = (Instant::now() - timeout_start).as_millis() as f64 / 1000.0;
+        } else {
+            active_pattern = rumble_iter.next().unwrap();
+            println!("Rumbling {:?} for {:?} seconds", active_pattern.1, active_pattern.0);
+
+            timeout = 0.0;
+            timeout_start = Instant::now();
+        }
+    });
+}

src/event/device.rs

@@ -1,7 +1,7 @@
 use platform_impl;
 use event::{AxisId, ButtonId, ElementState, KeyboardInput, MouseButton};
 use event_loop::EventLoop;
-use std::fmt;
+use std::{fmt, io};
 
 /// A hint suggesting the type of button that was pressed.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -131,6 +131,12 @@ pub enum GamepadEvent {
     },
 }
 
+#[derive(Debug)]
+pub enum RumbleError {
+    DeviceNotConnected,
+    OsError(io::Error),
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct MouseId(pub(crate) platform_impl::MouseId);
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -182,8 +188,8 @@ impl GamepadHandle {
         platform_impl::GamepadHandle::enumerate(&event_loop.event_loop)
     }
 
-    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
-        self.0.rumble(left_speed, right_speed);
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) -> Result<(), RumbleError> {
+        self.0.rumble(left_speed, right_speed)
     }
 
     pub fn port(&self) -> Option<u8> {

src/platform_impl/windows/gamepad.rs

@@ -2,7 +2,7 @@ use std::sync::Weak;
 
 use winapi::um::winnt::HANDLE;
 
-use event::device::GamepadEvent;
+use event::device::{GamepadEvent, RumbleError};
 use platform_impl::platform::raw_input::{get_raw_input_device_name, RawGamepad};
 use platform_impl::platform::xinput::{self, XInputGamepad, XInputGamepadShared};
 
@@ -64,11 +64,12 @@ impl Gamepad {
 }
 
 impl GamepadShared {
-    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) -> Result<(), RumbleError> {
         match self {
-            GamepadShared::Raw(_) => (),
-            GamepadShared::XInput(ref data) => {data.upgrade().map(|r| r.rumble(left_speed, right_speed));},
-            GamepadShared::Dummy => (),
+            GamepadShared::Raw(_) |
+            GamepadShared::Dummy => Ok(()),
+            GamepadShared::XInput(ref data) => data.upgrade().map(|r| r.rumble(left_speed, right_speed))
+                .unwrap_or(Err(RumbleError::DeviceNotConnected)),
         }
     }
 

src/platform_impl/windows/mod.rs

@@ -118,8 +118,8 @@ impl GamepadHandle {
         self.handle
     }
 
-    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
-        self.shared_data.rumble(left_speed, right_speed);
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) -> Result<(), ::event::device::RumbleError> {
+        self.shared_data.rumble(left_speed, right_speed)
     }
 
     pub fn port(&self) -> Option<u8> {

src/platform_impl/windows/xinput.rs

@@ -1,4 +1,4 @@
-use std::mem;
+use std::{io, mem};
 use std::sync::{Arc, Weak};
 
 use rusty_xinput::*;
@@ -7,7 +7,7 @@ use winapi::um::xinput::*;
 
 use event::{
     ElementState,
-    device::{AxisHint, ButtonHint, GamepadEvent, Side},
+    device::{AxisHint, ButtonHint, GamepadEvent, RumbleError, Side},
 };
 use platform_impl::platform::util;
 
@@ -49,10 +49,9 @@ pub fn id_from_name(name: &str) -> Option<DWORD> {
 
 #[derive(Debug)]
 pub struct XInputGamepad {
-    port: DWORD,
+    shared: Arc<XInputGamepadShared>,
     prev_state: Option<XInputState>,
     state: Option<XInputState>,
-    rumbler: Arc<XInputGamepadShared>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -63,17 +62,16 @@ pub struct XInputGamepadShared {
 impl XInputGamepad {
     pub fn new(port: DWORD) -> Option<Self> {
         XINPUT_GUARD.map(|_| XInputGamepad {
-            port,
+            shared: Arc::new(XInputGamepadShared {
+                port,
+            }),
             prev_state: None,
             state: None,
-            rumbler: Arc::new(XInputGamepadShared {
-                port,
-            })
         })
     }
 
     pub fn update_state(&mut self) -> Option<()> {
-        let state = xinput_get_state(self.port).ok();
+        let state = xinput_get_state(self.shared.port).ok();
         if state.is_some() {
             self.prev_state = mem::replace(&mut self.state, state);
             Some(())
@@ -244,7 +242,7 @@ impl XInputGamepad {
     }
 
     pub fn shared_data(&self) -> Weak<XInputGamepadShared> {
-        Arc::downgrade(&self.rumbler)
+        Arc::downgrade(&self.shared)
     }
 }
 
@@ -254,16 +252,22 @@ impl Drop for XInputGamepad {
         // after the gamepad was disconnected, all future attempts to read from a given port (even
         // if a controller was plugged back into said port) will fail! I don't know why that happens,
         // but this fixes it, so 🤷.
-        xinput_get_state(self.port).ok();
+        xinput_get_state(self.shared.port).ok();
     }
 }
 
 impl XInputGamepadShared {
-    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) -> Result<(), RumbleError> {
         let left_speed = (left_speed.max(0.0).min(1.0) * u16::max_value() as f64) as u16;
         let right_speed = (right_speed.max(0.0).min(1.0) * u16::max_value() as f64) as u16;
-        // TODO: We should probably return the status
-        let _ = xinput_set_state(self.port, left_speed, right_speed);
+
+        let result = xinput_set_state(self.port, left_speed, right_speed);
+        result.map_err(|e| match e {
+            XInputUsageError::XInputNotLoaded |
+            XInputUsageError::InvalidControllerID => panic!("unexpected xinput error {:?}; this is a bug and should be reported", e),
+            XInputUsageError::DeviceNotConnected => RumbleError::DeviceNotConnected,
+            XInputUsageError::UnknownError(code) => RumbleError::OsError(io::Error::from_raw_os_error(code as i32)),
+        })
     }
 
     pub fn port(&self) -> u8 {