chore: Warnings cleanup

crates/buttplug_server/src/device/protocol.rs

···
     let output_command = cmd.output_command();
     match output_command {
       OutputCommand::Constrict(x) => {
-        self.handle_output_constrict_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
+        self.handle_output_constrict_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Spray(x) => {
-        self.handle_output_spray_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
+        self.handle_output_spray_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Oscillate(x) => {
-        self.handle_output_oscillate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
+        self.handle_output_oscillate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Rotate(x) => {
         self.handle_output_rotate_cmd(cmd.feature_index(), cmd.feature_id(), x.value())
       }
       OutputCommand::Vibrate(x) => {
-        self.handle_output_vibrate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
+        self.handle_output_vibrate_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Position(x) => {
-        self.handle_output_position_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
+        self.handle_output_position_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Heater(x) => {
-        self.handle_output_heater_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
+        self.handle_output_heater_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::Led(x) => {
-        self.handle_output_led_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|e| ButtplugDeviceError::DeviceCommandSignError)?)
+        self.handle_output_led_cmd(cmd.feature_index(), cmd.feature_id(), x.value().try_into().map_err(|_| ButtplugDeviceError::DeviceCommandSignError)?)
       }
       OutputCommand::PositionWithDuration(x) => self.handle_position_with_duration_cmd(
         cmd.feature_index(),

crates/buttplug_server/src/device/protocol_impl/fredorch.rs

···
   }
 }
 
-const speed_matrix: [[u32; 20]; 15] = [
+const SPEED_MATRIX: [[u32; 20]; 15] = [
 // distance, speed 1-20
 /*      1     2     3     4     5     6     7     8     9    10   11   12   13   14   15   16   17   18   19   20 */
 /* 1*/ [1000, 800,  400,  235,  200,  172,  155,  92,   60,  45,  38,  34,  32,  28,  27,  26,  25,  24,  23,  22 ],
···
 /*15*/ [8048, 7068, 4442, 3708, 2668, 1930, 1800, 1520, 878, 618, 428, 365, 260, 255, 250, 240, 230, 220, 210, 200],
 ];
 
-fn calculate_speed(mut distance: u32, duration: u32) -> u8 {
+fn calculate_speed(distance: u32, duration: u32) -> u8 {
   let distance = distance.clamp(0,15);
   if distance == 0  {return 0;}
 
   let mut speed= 1;
   while speed < 20 {
-    if speed_matrix[distance as usize - 1][speed as usize - 1] < duration {
+    if SPEED_MATRIX[distance as usize - 1][speed as usize - 1] < duration {
       return speed;
     }
     speed += 1;

crates/buttplug_server/src/device/protocol_impl/galaku.rs

···
   new_data
 }
 
+fn send_bytes(data: Vec<u32>) -> Vec<u8> {
+  let mut new_data = vec![35];
+  new_data.extend(data);
+  new_data.push(new_data.iter().sum());
+  let mut uint8_array: Vec<u8> = Vec::new();
+  for value in encrypt(new_data) {
+    uint8_array.push(value as u8);
+  }
+  uint8_array
+}
+
+/*
+
 fn decrypt(data: Vec<u32>) -> Vec<u32> {
   let mut new_data = vec![data[0]];
   for i in 1..data.len() {
···
   new_data
 }
 
-fn send_bytes(data: Vec<u32>) -> Vec<u8> {
-  let mut new_data = vec![35];
-  new_data.extend(data);
-  new_data.push(new_data.iter().sum());
-  let mut uint8_array: Vec<u8> = Vec::new();
-  for value in encrypt(new_data) {
-    uint8_array.push(value as u8);
-  }
-  uint8_array
-}
 
 fn read_value(data: Vec<u8>) -> u32 {
   let mut uint32_data: Vec<u32> = Vec::new();
···
     0
   }
 }
+
+*/
 
 const GALAKU_PROTOCOL_UUID: Uuid = uuid!("766d15d5-0f43-4768-a73a-96ff48bc389e");
 generic_protocol_initializer_setup!(Galaku, "galaku");

crates/buttplug_server/src/device/protocol_impl/kiiroo_powershot.rs

···
     device: Arc<Hardware>,
     feature_index: u32,
     feature_id: Uuid,
-  ) -> BoxFuture<Result<InputReadingV4, ButtplugDeviceError>> {
+  ) -> BoxFuture<'_, Result<InputReadingV4, ButtplugDeviceError>> {
     debug!("Trying to get battery reading.");
     let msg = HardwareReadCmd::new(feature_id, Endpoint::RxBLEBattery, 20, 0);
     let fut = device.read_value(&msg);

crates/buttplug_server/src/device/protocol_impl/kiiroo_v21.rs

···
   util::stream::convert_broadcast_receiver_to_stream,
 };
 use buttplug_server_device_config::Endpoint;
-use dashmap::DashSet;
+// use dashmap::DashSet;
 use futures::{FutureExt, StreamExt, future::BoxFuture};
 use std::{
   default::Default,
···
 pub struct KiirooV21 {
   previous_position: Arc<AtomicU8>,
   // Set of sensors we've subscribed to for updates.
-  subscribed_sensors: Arc<DashSet<u32>>,
+  // subscribed_sensors: Arc<DashSet<u32>>,
   event_stream: broadcast::Sender<ButtplugServerDeviceMessage>,
 }
 
···
     let (sender, _) = broadcast::channel(256);
     Self {
       previous_position: Default::default(),
-      subscribed_sensors: Arc::new(DashSet::new()),
+      // subscribed_sensors: Arc::new(DashSet::new()),
       event_stream: sender,
     }
   }

crates/buttplug_server/src/device/protocol_impl/lovense/lovense_rotate_vibrator.rs

···
 };
 use buttplug_core::{errors::ButtplugDeviceError, message::InputReadingV4};
 use futures::future::BoxFuture;
-use std::sync::{
-  Arc,
-  atomic::{AtomicBool, Ordering},
-};
+use std::sync::Arc;
 use uuid::Uuid;
 
 #[derive(Default)]
-pub struct LovenseRotateVibrator {
-  clockwise: AtomicBool,
-}
+pub struct LovenseRotateVibrator {}
 
 impl ProtocolHandler for LovenseRotateVibrator {
   fn keepalive_strategy(&self) -> ProtocolKeepaliveStrategy {

crates/buttplug_server/src/device/protocol_impl/lovense/mod.rs

···
 
     // New Lovense devices seem to be moving to the simplified LVS:<bytearray>; command format.
     // I'm not sure if there's a good way to detect this.
-    let use_lvs = device_type == "OC";
+    //let use_lvs = device_type == "OC";
 
     debug!(
       "Device type {} initialized with {} vibrators {} using Mply",

crates/buttplug_server/src/message/v1/spec_enums.rs

···
   }
 }
 
+// Leave this in for consistency sake, mostly for implementing backward compat tests
+#[allow(dead_code)]
 #[derive(Copy, Debug, Clone, PartialEq, Eq, Hash, Display, Serialize, Deserialize)]
 pub enum ButtplugDeviceMessageNameV1 {
   VibrateCmd,

crates/buttplug_server/src/message/v3/client_device_message_attributes.rs

···
   v2::{ClientDeviceMessageAttributesV2, GenericDeviceMessageAttributesV2},
 };
 use buttplug_core::message::{
-  DeviceFeature, DeviceFeatureOutputLimits, DeviceFeatureOutputValueProperties, InputCommandType, InputType, OutputType
+  DeviceFeature, DeviceFeatureOutputValueProperties, InputCommandType, InputType, OutputType
 };
 use getset::{Getters, MutGetters, Setters};
 use serde::{Deserialize, Serialize, Serializer, ser::SerializeSeq};

crates/buttplug_server_device_config/src/device_config_file/base.rs

···
     self.version
   }
 }
-
-impl BaseConfigFile {
-  pub(crate) fn new(major_version: u32, minor_version: u32) -> Self {
-    Self {
-      version: ConfigVersion {
-        major: major_version,
-        minor: minor_version,
-      },
-      protocols: None,
-    }
-  }
-}

crates/buttplug_server_device_config/src/device_config_file/mod.rs

···
 mod user;
 
 use base::BaseConfigFile;
-use uuid::Uuid;
 
-use crate::{UserDeviceIdentifier, device_config_file::{
+use crate::{device_config_file::{
   protocol::ProtocolDefinition,
   user::{UserConfigDefinition, UserConfigFile, UserDeviceConfigPair},
 }};

crates/buttplug_tests/tests/mod.rs

···
-extern crate tracing;
 #[macro_use]
 extern crate log;
 pub mod util;

crates/intiface_engine/src/engine.rs

···
 
     // Hang out until those listeners get sick of listening.
     info!("Intiface CLI Setup finished, running server tasks until all joined.");
-    let mut server = setup_buttplug_server(options, &self.backdoor_server, dcm).await?;
+    let server = setup_buttplug_server(options, &self.backdoor_server, dcm).await?;
     let dcm = server
       .device_manager()
       .device_configuration_manager()