chore: Implement replay keepalive strategy

buttplug/src/server/device/protocol/adrienlastic.rs

···
 pub struct AdrienLastic {}
 
 impl ProtocolHandler for AdrienLastic {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+      super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/aneros.rs

···
 pub struct Aneros {}
 
 impl ProtocolHandler for Aneros {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     index: u32,

buttplug/src/server/device/protocol/ankni.rs

···
 pub struct Ankni {}
 
 impl ProtocolHandler for Ankni {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/buttplug_passthru.rs

···
 struct ButtplugPassthru {}
 
 impl ProtocolHandler for ButtplugPassthru {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn has_handle_message(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/cachito.rs

···
 pub struct Cachito {}
 
 impl ProtocolHandler for Cachito {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     index: u32,

buttplug/src/server/device/protocol/cowgirl.rs

···
 pub struct Cowgirl {}
 
 impl ProtocolHandler for Cowgirl {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/foreo.rs

···
 pub struct Foreo {}
 
 impl ProtocolHandler for Foreo {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _: u32,

buttplug/src/server/device/protocol/fox.rs

···
 pub struct Fox {}
 
 impl ProtocolHandler for Fox {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/galaku_pump.rs

···
 pub struct GalakuPump {}
 
 impl ProtocolHandler for GalakuPump {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/hismith.rs

···
 pub struct Hismith {}
 
 impl ProtocolHandler for Hismith {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_oscillate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/hismith_mini.rs

···
 }
 
 impl ProtocolHandler for HismithMini {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_oscillate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/htk_bm.rs

···
 pub struct HtkBm {}
 
 impl ProtocolHandler for HtkBm {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],
···
     Ok(cmd_vec)
   }
 }
-
-#[cfg(all(test, feature = "server"))]
-mod test {
-  use super::HtkBm;
-  use crate::{
-    core::message::{ActuatorType, Endpoint},
-    server::device::{
-      hardware::{HardwareCommand, HardwareWriteCmd},
-      protocol::ProtocolHandler,
-    },
-  };
-
-  #[test]
-  pub fn test_htkbm_protocol() {
-    let handler = HtkBm {};
-    assert_eq!(
-      handler.handle_scalar_cmd(&vec![
-        Some((ActuatorType::Vibrate, 0)),
-        Some((ActuatorType::Vibrate, 0))
-      ]),
-      Ok(vec![HardwareCommand::Write(HardwareWriteCmd::new(
-        Endpoint::Tx,
-        vec![15],
-        false
-      ))])
-    );
-    assert_eq!(
-      handler.handle_scalar_cmd(&vec![
-        Some((ActuatorType::Vibrate, 1)),
-        Some((ActuatorType::Vibrate, 0))
-      ]),
-      Ok(vec![HardwareCommand::Write(HardwareWriteCmd::new(
-        Endpoint::Tx,
-        vec![12],
-        false
-      ))])
-    );
-    assert_eq!(
-      handler.handle_scalar_cmd(&vec![
-        Some((ActuatorType::Vibrate, 0)),
-        Some((ActuatorType::Vibrate, 1))
-      ]),
-      Ok(vec![HardwareCommand::Write(HardwareWriteCmd::new(
-        Endpoint::Tx,
-        vec![13],
-        false
-      ))])
-    );
-    assert_eq!(
-      handler.handle_scalar_cmd(&vec![
-        Some((ActuatorType::Vibrate, 1)),
-        Some((ActuatorType::Vibrate, 1))
-      ]),
-      Ok(vec![HardwareCommand::Write(HardwareWriteCmd::new(
-        Endpoint::Tx,
-        vec![11],
-        false
-      ))])
-    );
-  }
-}

buttplug/src/server/device/protocol/jejoue.rs

···
 pub struct JeJoue {}
 
 impl ProtocolHandler for JeJoue {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/protocol/kiiroo_v2_vibrator.rs

···
 pub struct KiirooV2Vibrator {}
 
 impl ProtocolHandler for KiirooV2Vibrator {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/protocol/kizuna.rs

···
 pub struct Kizuna {}
 
 impl ProtocolHandler for Kizuna {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_rotate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/lelof1s.rs

···
 pub struct LeloF1s {}
 
 impl ProtocolHandler for LeloF1s {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/lelof1sv2.rs

···
 pub struct LeloF1sV2 {}
 
 impl ProtocolHandler for LeloF1sV2 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/libo_elle.rs

···
 pub struct LiboElle {}
 
 impl ProtocolHandler for LiboElle {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     index: u32,

buttplug/src/server/device/protocol/libo_shark.rs

···
 pub struct LiboShark {}
 
 impl ProtocolHandler for LiboShark {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/protocol/libo_vibes.rs

···
 pub struct LiboVibes {}
 
 impl ProtocolHandler for LiboVibes {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/protocol/lovedistance.rs

···
 pub struct LoveDistance {}
 
 impl ProtocolHandler for LoveDistance {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/lovehoney_desire.rs

···
 pub struct LovehoneyDesire {}
 
 impl ProtocolHandler for LovehoneyDesire {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/lovenuts.rs

···
 pub struct LoveNuts {}
 
 impl ProtocolHandler for LoveNuts {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/magic_motion_v1.rs

···
 pub struct MagicMotionV1 {}
 
 impl ProtocolHandler for MagicMotionV1 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/magic_motion_v2.rs

···
 pub struct MagicMotionV2 {}
 
 impl ProtocolHandler for MagicMotionV2 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/magic_motion_v3.rs

···
 pub struct MagicMotionV3 {}
 
 impl ProtocolHandler for MagicMotionV3 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/magic_motion_v4.rs

···
 pub struct MagicMotionV4 {}
 
 impl ProtocolHandler for MagicMotionV4 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/mannuo.rs

···
 pub struct ManNuo {}
 
 impl ProtocolHandler for ManNuo {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/maxpro.rs

···
 pub struct Maxpro {}
 
 impl ProtocolHandler for Maxpro {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,
···
     Ok(vec![HardwareWriteCmd::new(Endpoint::Tx, data, false).into()])
   }
 }
-
-// TODO Write some tests! Especially with the weird operational range on this.

buttplug/src/server/device/protocol/meese.rs

···
 pub struct Meese {}
 
 impl ProtocolHandler for Meese {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
-    _index: u32,
+    index: u32,
     scalar: u32,
   ) -> Result<Vec<HardwareCommand>, ButtplugDeviceError> {
     Ok(vec![HardwareWriteCmd::new(
       Endpoint::Tx,
-      vec![0x01, 0x80, 0x01 + (_index as u8), (scalar as u8)],
+      vec![0x01, 0x80, 0x01 + (index as u8), (scalar as u8)],
       true,
     )
     .into()])

buttplug/src/server/device/protocol/metaxsire.rs

···
 pub struct MetaXSire {}
 
 impl ProtocolHandler for MetaXSire {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/mizzzee.rs

···
 pub struct MizzZee {}
 
 impl ProtocolHandler for MizzZee {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/mizzzee_v2.rs

···
 pub struct MizzZeeV2 {}
 
 impl ProtocolHandler for MizzZeeV2 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/mod.rs

···
 /// things alive. Currently this only applies to iOS backgrounding with bluetooth devices, but since
 /// we never know which of our hundreds of supported devices someone might connect, we need context
 /// as to which keepalive strategy to use.
+/// 
+/// When choosing a keepalive strategy for a protocol:
+/// 
+/// - All protocols use NoStrategy by default. For many devices, sending trash will break them in
+///   very weird ways and we can't risk that, so we need to know the protocol context.
+/// - If the protocol already needs its own keepalive (Satisfyer, Mysteryvibe, etc...), use
+///   NoStrategy for now. RepeatLastPacketStrategy could be used, but we'd need per-protocol
+///   timeouts at that point.
+/// - If the protocol has a command that essentially does nothing to the actuators, set up
+///   RepeatPacketStrategy to use that. This is useful for devices that have info commands (like
+///   Lovense), ping commands (like The Handy), sensor commands that aren't yet subscribed to output
+///   notifications, etc...
+/// - For many devices with only scalar actuators, RepeatLastPacketStrategy should work. You just
+///   need to make sure the protocol doesn't have a packet counter or something else that will trip
+///   if the same packet is replayed multiple times.
+/// - For all other devices, use Custom Strategy. This assumes the protocol will have implemented a
+///   method to generate a valid packet.
 #[derive(Debug)]
 pub enum ProtocolKeepaliveStrategy {
   /// Do nothing. This is for protocols that already require internal keepalives, like satisfyer,
···
   /// Repeat whatever the last packet sent was, and send Stop commands until first packet sent. This
   /// will be useful for most devices that purely use scalar commands.
   RepeatLastPacketStrategy,
-  /// Request battery values as the keep alive.
-  BatteryStrategy,
-  /// Protocol implements a custom strategy, use that.
-  CustomStrategy,
+  /// Call a specific method on the protocol implementation to generate keepalive packets.
+  CustomStrategy
 }
 
 pub trait ProtocolIdentifierFactory: Send + Sync {

buttplug/src/server/device/protocol/motorbunny.rs

···
 pub struct Motorbunny {}
 
 impl ProtocolHandler for Motorbunny {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/nobra.rs

···
 pub struct Nobra {}
 
 impl ProtocolHandler for Nobra {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/patoo.rs

···
 pub struct Patoo {}
 
 impl ProtocolHandler for Patoo {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/protocol/picobong.rs

···
 pub struct Picobong {}
 
 impl ProtocolHandler for Picobong {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/pink_punch.rs

···
 pub struct PinkPunch {}
 
 impl ProtocolHandler for PinkPunch {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/prettylove.rs

···
 pub struct PrettyLove {}
 
 impl ProtocolHandler for PrettyLove {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/realov.rs

···
 pub struct Realov {}
 
 impl ProtocolHandler for Realov {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/sakuraneko.rs

···
 pub struct Sakuraneko {}
 
 impl ProtocolHandler for Sakuraneko {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/sensee.rs

···
 pub struct Sensee {}
 
 impl ProtocolHandler for Sensee {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/svakom.rs

···
 pub struct Svakom {}
 
 impl ProtocolHandler for Svakom {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/svakom_alex.rs

···
 pub struct SvakomAlex {}
 
 impl ProtocolHandler for SvakomAlex {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/svakom_alex_v2.rs

···
 pub struct SvakomAlexV2 {}
 
 impl ProtocolHandler for SvakomAlexV2 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/svakom_barnard.rs

···
 pub struct SvakomBarnard {}
 
 impl ProtocolHandler for SvakomBarnard {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/svakom_iker.rs

···
 }
 
 impl ProtocolHandler for SvakomIker {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/protocol/svakom_pulse.rs

···
 pub struct SvakomPulse {}
 
 impl ProtocolHandler for SvakomPulse {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/svakom_sam.rs

···
 pub struct SvakomSam {}
 
 impl ProtocolHandler for SvakomSam {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/protocol/svakom_v2.rs

···
 pub struct SvakomV2 {}
 
 impl ProtocolHandler for SvakomV2 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     index: u32,

buttplug/src/server/device/protocol/svakom_v3.rs

···
 pub struct SvakomV3 {}
 
 impl ProtocolHandler for SvakomV3 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/svakom_v4.rs

···
 pub struct SvakomV4 {}
 
 impl ProtocolHandler for SvakomV4 {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/synchro.rs

···
 pub struct Synchro {}
 
 impl ProtocolHandler for Synchro {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_rotate_cmd(
     &self,
     cmds: &[Option<(u32, bool)>],

buttplug/src/server/device/protocol/tryfun.rs

···
 pub struct TryFun {}
 
 impl ProtocolHandler for TryFun {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_oscillate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/wetoy.rs

···
 pub struct WeToy {}
 
 impl ProtocolHandler for WeToy {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/wevibe.rs

···
 pub struct WeVibe {}
 
 impl ProtocolHandler for WeVibe {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/wevibe8bit.rs

···
 pub struct WeVibe8Bit {}
 
 impl ProtocolHandler for WeVibe8Bit {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/wevibe_chorus.rs

···
 pub struct WeVibeChorus {}
 
 impl ProtocolHandler for WeVibeChorus {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn needs_full_command_set(&self) -> bool {
     true
   }

buttplug/src/server/device/protocol/xibao.rs

···
 pub struct Xibao {}
 
 impl ProtocolHandler for Xibao {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_oscillate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/xiuxiuda.rs

···
 pub struct Xiuxiuda {}
 
 impl ProtocolHandler for Xiuxiuda {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/youcups.rs

···
 pub struct Youcups {}
 
 impl ProtocolHandler for Youcups {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_vibrate_cmd(
     &self,
     _index: u32,

buttplug/src/server/device/protocol/zalo.rs

···
 pub struct Zalo {}
 
 impl ProtocolHandler for Zalo {
+  fn keepalive_strategy(&self) -> super::ProtocolKeepaliveStrategy {
+    super::ProtocolKeepaliveStrategy::RepeatLastPacketStrategy
+  }
+
   fn handle_scalar_cmd(
     &self,
     cmds: &[Option<(ActuatorType, u32)>],

buttplug/src/server/device/server_device.rs

···
 use futures::future::{self, FutureExt};
 use getset::{Getters, MutGetters, Setters};
 use serde::{Deserialize, Serialize};
+use tokio::sync::RwLock;
 use tokio_stream::StreamExt;
 
 use super::{
   configuration::{ProtocolDeviceAttributes, ServerDeviceMessageAttributes},
-  protocol::{generic_command_manager::GenericCommandManager, ProtocolSpecializer, ProtocolKeepaliveStrategy},
+  protocol::{generic_command_manager::GenericCommandManager, ProtocolSpecializer, ProtocolKeepaliveStrategy}, hardware::HardwareWriteCmd,
 };
 
 #[derive(Debug)]
···
     .initialize(hardware.clone(), &attrs)
     .await?;
 
+  let requires_keepalive = hardware.requires_keepalive();
+  let strategy = handler.keepalive_strategy();
+
   // We now have fully initialized hardware, return a server device.
-  Ok(ServerDevice::new(identifier, handler, hardware, &attrs))
+  let device = ServerDevice::new(identifier, handler, hardware, &attrs);
+  
+  // If we need a keepalive with a packet replay, set this up via stopping the device on connect.
+  if requires_keepalive && matches!(strategy, ProtocolKeepaliveStrategy::RepeatLastPacketStrategy) {
+    if let Err(e) = device.handle_stop_device_cmd().await {
+      return Err(ButtplugDeviceError::DeviceConnectionError(format!("Error setting up keepalive: {}", e)));
+    }
+  }
+
+  Ok(device)
 }
 
 pub struct ServerDevice {
···
   /// Unique identifier for the device
   identifier: ServerDeviceIdentifier,
   raw_subscribed_endpoints: Arc<DashSet<Endpoint>>,
+  keepalive_packet: Arc<RwLock<Option<HardwareWriteCmd>>>
 }
 impl Debug for ServerDevice {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
···
     hardware: Arc<Hardware>,
     attributes: &ProtocolDeviceAttributes,
   ) -> Self {
+    let keepalive_packet = Arc::new(RwLock::new(None));
+    let gcm = GenericCommandManager::new(attributes);
     // If we've gotten here, we know our hardware is connected. This means we can start the keepalive if it's required.
     if hardware.requires_keepalive() && !matches!(handler.keepalive_strategy(), ProtocolKeepaliveStrategy::NoStrategy) {
       let hardware = hardware.clone();
       let strategy = handler.keepalive_strategy();
+      let keepalive_packet = keepalive_packet.clone();
       tokio::spawn(async move {
         // Arbitrary wait time for now.
         let wait_duration = Duration::from_secs(5);
···
                   break;
                 }
               }
+              ProtocolKeepaliveStrategy::RepeatLastPacketStrategy => {
+                if let Some(packet) = &*keepalive_packet.read().await {
+                  hardware.write_value(&packet);
+                }
+              },
               _ => {
                 info!("Protocol keepalive strategy {:?} not implemented, replacing with NoStrategy", strategy);
               }
···
 
     Self {
       identifier,
-      generic_command_manager: GenericCommandManager::new(attributes),
+      generic_command_manager: gcm,
       handler,
       hardware,
+      keepalive_packet,
       attributes: attributes.clone(),
       raw_subscribed_endpoints: Arc::new(DashSet::new()),
     }
···
 
   fn handle_hardware_commands(&self, commands: Vec<HardwareCommand>) -> ButtplugServerResultFuture {
     let hardware = self.hardware.clone();
+    let keepalive_type = self.handler.keepalive_strategy();
+    let keepalive_packet = self.keepalive_packet.clone();
     async move {
       // Run commands in order, otherwise we may end up sending out of order. This may take a while,
       // but it's what 99% of protocols expect. If they want something else, they can implement it
···
       // disconnected.
       for command in commands {
         hardware.parse_message(&command).await?;
+        if hardware.requires_keepalive() && matches!(keepalive_type, ProtocolKeepaliveStrategy::RepeatLastPacketStrategy) {
+          if let HardwareCommand::Write(command) = command {
+            *keepalive_packet.write().await = Some(command);
+          }
+        }
       }
       Ok(message::Ok::default().into())
     }