Try reorder of init loop

CHANGELOG.md

@@ -5,6 +5,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+## [0.14.4] - 2020-07-07
+### Changed
+- Changes to the way rog-core is initialised
+
 ## [0.14.3] - 2020-05-07
 ### Changed
 - Proper fix of laptop mode conversion bug

rog-core/src/animatrix_control.rs

@@ -11,7 +11,7 @@ const SET: u8 = 0xc4;
 
 use log::{error, warn};
 use rog_client::error::AuraError;
-use rusb::DeviceHandle;
+use rusb::{Device, DeviceHandle};
 use std::error::Error;
 use std::time::Duration;
 
@@ -33,34 +33,41 @@ impl AniMeWriter {
     #[inline]
     pub fn new() -> Result<AniMeWriter, Box<dyn Error>> {
         // We don't expect this ID to ever change
-        let mut dev_handle = AniMeWriter::get_device(0x0b05, 0x193b).map_err(|err| {
+        let device = AniMeWriter::get_device(0x0b05, 0x193b).map_err(|err| {
             warn!("Could not get AniMe display handle: {:?}", err);
             err
         })?;
-        dev_handle.reset()?;
-        // This config seems to be the required device config for writing
-        dev_handle.set_active_configuration(1).unwrap_or(());
 
-        // For the animatrix device there is only one interface and one endpoint
-        let interface = 0;
+        let mut device = device.open()?;
+        device.reset()?;
 
-        dev_handle
-            .set_auto_detach_kernel_driver(true)
-            .map_err(|err| {
-                error!("Auto-detach kernel driver failed: {:?}", err);
-                err
-            })?;
-        dev_handle.claim_interface(interface).map_err(|err| {
+        device.set_auto_detach_kernel_driver(true).map_err(|err| {
+            error!("Auto-detach kernel driver failed: {:?}", err);
+            err
+        })?;
+
+        device.claim_interface(0).map_err(|err| {
             error!("Could not claim device interface: {:?}", err);
             err
         })?;
 
         Ok(AniMeWriter {
-            handle: dev_handle,
+            handle: device,
             initialised: false,
         })
     }
 
+    #[inline]
+    fn get_device(vendor: u16, product: u16) -> Result<Device<rusb::GlobalContext>, rusb::Error> {
+        for device in rusb::devices()?.iter() {
+            let device_desc = device.device_descriptor()?;
+            if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
+                return Ok(device);
+            }
+        }
+        Err(rusb::Error::NoDevice)
+    }
+
     pub async fn do_command(&mut self, command: AnimatrixCommand) -> Result<(), AuraError> {
         if !self.initialised {
             self.do_initialization().await?
@@ -125,21 +132,6 @@ impl AniMeWriter {
         Ok(())
     }
 
-    // TODO: save/reload last frame
-    #[inline]
-    fn get_device(
-        vendor: u16,
-        product: u16,
-    ) -> Result<DeviceHandle<rusb::GlobalContext>, rusb::Error> {
-        for device in rusb::devices()?.iter() {
-            let device_desc = device.device_descriptor()?;
-            if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
-                return device.open();
-            }
-        }
-        Err(rusb::Error::NoDevice)
-    }
-
     #[inline]
     async fn do_initialization(&mut self) -> Result<(), AuraError> {
         let mut init = [0; PACKET_SIZE];

rog-core/src/rogcore.rs

@@ -2,7 +2,7 @@
 
 use crate::{config::Config, error::RogError, virt_device::VirtKeys};
 use log::{error, info, warn};
-use rusb::DeviceHandle;
+use rusb::{Device, DeviceHandle};
 use std::error::Error;
 use std::fs::OpenOptions;
 use std::io::Write;
@@ -35,16 +35,17 @@ pub struct RogCore {
 
 impl RogCore {
     pub fn new(vendor: u16, product: u16, match_endpoint: u8) -> Result<RogCore, Box<dyn Error>> {
-        let mut dev_handle = RogCore::get_device(vendor, product).map_err(|err| {
-            error!("Could not get keyboard device handle: {:?}", err);
+        let device = RogCore::get_device(vendor, product).map_err(|err| {
+            error!("Could not find keyboard device: {:?}", err);
             err
         })?;
-        dev_handle.set_active_configuration(0).unwrap_or(());
 
-        let dev_config = dev_handle.device().config_descriptor(0).map_err(|err| {
+        let dev_config = device.config_descriptor(0).map_err(|err| {
             error!("Could not get keyboard device config: {:?}", err);
             err
         })?;
+        info!("ACTIVE CONFIG: {:?}", dev_config.number());
+
         // Interface with outputs
         let mut interface = 2; // The interface with keyboard consumer device and LED control
                                // is #2 on 0x1866 device at least
@@ -65,39 +66,29 @@ impl RogCore {
             }
         }
 
-        if let Err(err) = dev_handle.set_auto_detach_kernel_driver(true) {
+        let mut device = device.open().map_err(|err| {
+            error!("Could not open device: {:?}", err);
+            err
+        })?;
+
+        if let Err(err) = device.set_auto_detach_kernel_driver(true) {
             warn!("Auto-detach kernel driver failed: {:?}", err);
-            let mut fail_count = 5;
-            while fail_count > 0 {
-                warn!("Trying device reset");
-                fail_count -= 1;
-                dev_handle.reset()?;
-                std::thread::sleep(std::time::Duration::from_millis(500));
-                dev_handle
-                    .set_auto_detach_kernel_driver(true)
-                    .map_err(|err| {
-                        error!("Auto-detach kernel driver failed: {:?}", err);
-                        err
-                    })?;
-            }
+            warn!("Trying device reset");
+            device.reset()?;
+            std::thread::sleep(std::time::Duration::from_millis(500));
+            device.set_auto_detach_kernel_driver(true)?;
         }
 
-        if let Err(err) = dev_handle.claim_interface(interface) {
+        if let Err(err) = device.claim_interface(interface) {
             warn!("Could not claim keyboard device interface: {:?}", err);
-            let mut fail_count = 5;
-            while fail_count > 0 {
-                warn!("Sleeping");
-                fail_count -= 1;
-                std::thread::sleep(std::time::Duration::from_millis(500));
-                dev_handle.claim_interface(interface).map_err(|err| {
-                    error!("Could not claim keyboard device interface: {:?}", err);
-                    err
-                })?;
-            }
+            warn!("Sleeping 5 seconds");
+            std::thread::sleep(std::time::Duration::from_millis(5000));
+            device.claim_interface(interface)?;
         }
 
+        // std::thread::sleep(std::time::Duration::from_millis(500));
         Ok(RogCore {
-            handle: dev_handle,
+            handle: device,
             virt_keys: VirtKeys::new(),
             _pin: PhantomPinned,
         })
@@ -107,14 +98,11 @@ impl RogCore {
         &mut self.virt_keys
     }
 
-    fn get_device(
-        vendor: u16,
-        product: u16,
-    ) -> Result<DeviceHandle<rusb::GlobalContext>, rusb::Error> {
+    fn get_device(vendor: u16, product: u16) -> Result<Device<rusb::GlobalContext>, rusb::Error> {
         for device in rusb::devices()?.iter() {
             let device_desc = device.device_descriptor()?;
             if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
-                return device.open();
+                return Ok(device);
             }
         }
         Err(rusb::Error::NoDevice)