chore: Reenable Lovense Connect

For now. It needs to go away, and the sooner the better.

Author: qdot

crates/buttplug_core/src/message/v4/input_reading.rs

@@ -34,6 +34,12 @@ where
   }
 }
 
+impl From<u8> for InputValue<u8> {
+  fn from(value: u8) -> Self {
+    InputValue::new(value)
+  }
+}
+
 #[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum InputTypeReading {
   Battery(InputValue<u8>),

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

@@ -259,202 +259,6 @@ impl ProtocolInitializer for LovenseInitializer {
     }
   }
 }
-/*
-pub struct Lovense {
-  rotation_direction: AtomicBool,
-  vibrator_values: Vec<AtomicU32>,
-  use_mply: bool,
-  use_lvs: bool,
-  device_type: String,
-  value_cache: DashMap<Uuid, u32>,
-  linear_info: Arc<(AtomicU32, AtomicU32)>,
-}
-
-impl Lovense {
-  pub fn new(
-    device_type: &str,
-    vibrator_count: usize,
-    use_mply: bool,
-    use_lvs: bool,
-  ) -> Self {
-    let linear_info = Arc::new((AtomicU32::new(0), AtomicU32::new(0)));
-
-    let mut vibrator_values = vec![];
-    for _ in 0..vibrator_count {
-      vibrator_values.push(AtomicU32::new(0));
-    }
-
-    Self {
-      rotation_direction: AtomicBool::new(false),
-      vibrator_values,
-      use_mply,
-      use_lvs,
-      device_type: device_type.to_owned(),
-      value_cache: DashMap::new(),
-      linear_info,
-    }
-  }
-
-  fn handle_lvs_cmd(&self) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    let mut speeds = "LVS:{}".as_bytes().to_vec();
-    for i in self.vibrator_values.iter() {
-      speeds.push(i.load(Ordering::Relaxed) as u8);
-    }
-    speeds.push(0x3b);
-
-    Ok(vec![HardwareWriteCmd::new(
-      LOVENSE_PROTOCOL_UUID,
-      Endpoint::Tx,
-      speeds,
-      false,
-    )
-    .into()])
-  }
-
-  fn handle_mply_cmd(&self) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    /*
-    let mut speeds = cmds
-      .iter()
-      .map(|x| {
-        if let Some(val) = x {
-          val.1.to_string()
-        } else {
-          "-1".to_string()
-        }
-      })
-      .collect::<Vec<_>>();
-
-    if speeds.len() == 1 && self.device_type == "H" {
-      // Max range unless stopped
-      speeds.push(if speeds[0] == "0" {
-        "0".to_string()
-      } else {
-        "20".to_string()
-      });
-    }
-
-    let lovense_cmd = format!("Mply:{};", speeds.join(":")).as_bytes().to_vec();
-
-    Ok(vec![HardwareWriteCmd::new(
-      Endpoint::Tx,
-      lovense_cmd,
-      false,
-    )
-    .into()])
-    */
-    Ok(vec![])
-  }
-}
-
-impl ProtocolHandler for Lovense {
-  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
-    // For Lovense, we'll just repeat the device type packet and drop the result.
-    super::ProtocolKeepaliveStrategy::HardwareRequiredRepeatPacketStrategy(HardwareWriteCmd::new(
-      LOVENSE_PROTOCOL_UUID,
-      Endpoint::Tx,
-      b"DeviceType;".to_vec(),
-      false,
-    ))
-  }
-
-  fn handle_output_vibrate_cmd(
-    &self,
-    feature_index: u32,
-    feature_id: Uuid,
-    speed: u32,
-  ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
-    let current_vibrator_value =
-      self.vibrator_values[feature_index as usize].load(Ordering::Relaxed);
-    if current_vibrator_value == speed {
-      Ok(vec![])
-    } else {
-      self.vibrator_values[feature_index as usize].store(speed, Ordering::Relaxed);
-      let speeds: Vec<u32> = self
-        .vibrator_values
-        .iter()
-        .map(|v| v.load(Ordering::Relaxed))
-        .collect();
-      if self.use_lvs {
-        self.handle_lvs_cmd()
-      } else if self.use_mply {
-        self.handle_mply_cmd()
-      } else {
-        let lovense_cmd = if self.vibrator_values.len() == 1 {
-          format!("Vibrate:{speed};").as_bytes().to_vec()
-        } else {
-          format!("Vibrate{}:{};", feature_index + 1, speed)
-            .as_bytes()
-            .to_vec()
-        };
-        Ok(vec![HardwareWriteCmd::new(
-          &[feature_id],
-          Endpoint::Tx,
-          lovense_cmd,
-          false,
-        )
-        .into()])
-      }
-    }
-    /*
-    if self.use_lvs {
-      self.handle_lvs_cmd(cmd)
-    } else if self.use_mply {
-      self.handle_mply_cmd(cmd)
-    } else {
-      // Handle vibration commands, these will be by far the most common. Fucking machine oscillation
-      // uses lovense vibrate commands internally too, so we can include them here.
-      let vibrate_cmds: Vec<> = cmds
-        .iter()
-        .filter(|x| {
-          if let Some(val) = x {
-            [ActuatorType::Vibrate, ActuatorType::Oscillate].contains(&val.0)
-          } else {
-            false
-          }
-        })
-        .map(|x| x.as_ref().expect("Already verified is some"))
-        .collect();
-            if !vibrate_cmds.is_empty() {
-      // Lovense is the same situation as the Lovehoney Desire, where commands
-      // are different if we're addressing all motors or seperate motors.
-      // Difference here being that there's Lovense variants with different
-      // numbers of motors.
-      //
-      // Neat way of checking if everything is the same via
-      // https://sts10.github.io/2019/06/06/is-all-equal-function.html.
-      //
-      // Just make sure we're not matching on None, 'cause if that's the case
-      // we ain't got shit to do.
-      //
-      // Note that the windowed comparison causes mixed types as well as mixed
-      // speeds to fall back to separate commands. This is because the Gravity's
-      // thruster on Vibrate2 is independent of Vibrate
-      if self.vibrator_count == vibrate_cmds.len()
-        && (self.vibrator_count == 1
-          || vibrate_cmds
-            .windows(2)
-            .all(|w| w[0].0 == w[1].0 && w[0].1 == w[1].1))
-      {
-        let lovense_cmd = format!("Vibrate:{};", vibrate_cmds[0].1)
-          .as_bytes()
-          .to_vec();
-        hardware_cmds.push(HardwareWriteCmd::new(Endpoint::Tx, lovense_cmd, false).into());
-      } else {
-        for (i, cmd) in cmds.iter().enumerate() {
-          if let Some((actuator, speed)) = cmd {
-            if ![ActuatorType::Vibrate, ActuatorType::Oscillate].contains(actuator) {
-              continue;
-            }
-            let lovense_cmd = format!("Vibrate{}:{};", i + 1, speed).as_bytes().to_vec();
-            hardware_cmds.push(HardwareWriteCmd::new(Endpoint::Tx, lovense_cmd, false).into());
-          }
-        }
-      }
-    }
-      */
-  }
-}
-  */
 
 fn handle_battery_level_cmd(
   device_index: u32,