maxscout/HyperHeadset
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add support for old cloud 2

Browse Source
This commit is contained in:
Lennard Kittner
2025-08-24 12:15:40 +02:00
parent 6eabd6867e
commit 6840cec0f2
5 changed files with 279 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/bin/hyper_headset_cli.rs
View File

@@ -21,7 +21,7 @@ fn main() {
Arg::new("mute")
.long("mute")
.required(false)
.help("Mute or un mute the headset.")
.help("Mute or unmute the headset.")
.value_parser(clap::value_parser!(bool)),
)
.arg(
@@ -45,6 +45,13 @@ fn main() {
.help("Enable voice prompt. This may not be supported on your device.")
.value_parser(clap::value_parser!(bool)),
)
.arg(
Arg::new("surround_sound")
.long("surround_sound")
.required(false)
.help("Enables surround sound. This may be on by default and cannot be changed on your device.")
.value_parser(clap::value_parser!(bool)),
)
.get_matches();
let mut device = match connect_compatible_device() {
@@ -108,6 +115,16 @@ fn main() {
}
}
if let Some(surround_sound) = matches.get_one::<bool>("surround_sound") {
if let Some(packet) = device.set_surround_sound_packet(*surround_sound) {
if let Err(err) = device.get_device_state().hid_device.write(&packet) {
println!("Failed to set surround sound with error: {:?}", err)
}
} else {
println!("Can't change surround sound on this device")
}
}
std::thread::sleep(Duration::from_secs_f64(0.5));
if let Err(error) = device.active_refresh_state() {
@@ -116,11 +133,3 @@ fn main() {
};
println!("{}", device.get_device_state());
}
#[test]
fn test_basic_device_access() {
let _ = match CloudIIWirelessDTS::new() {
Ok(device) => device,
Err(_) => return,
};
}

195
src/devices/cloud_ii_wireless.rs Normal file
View File

@@ -0,0 +1,195 @@
use crate::devices::{ChargingStatus, Device, DeviceError, DeviceEvent, DeviceState};
use std::time::Duration;
const HYPERX: u16 = 0x0951;
pub const VENDOR_IDS: [u16; 1] = [HYPERX];
// Possible Cloud II Wireless product IDs
pub const PRODUCT_IDS: [u16; 3] = [0x1718, 0x018B, 0x0b92];
const BASE_PACKET: [u8; 62] = {
let mut tmp = [0u8; 62];
tmp[0] = 0x06;
tmp[1] = 0x00;
tmp[2] = 0x02;
tmp[3] = 0x00;
tmp[4] = 0x9A;
tmp[5] = 0x00;
tmp[6] = 0x00;
tmp[7] = 0x68;
tmp[8] = 0x4A;
tmp[9] = 0x8E;
tmp[10] = 0x0A;
tmp[11] = 0x00;
tmp[12] = 0x00;
tmp[13] = 0x00;
tmp[14] = 0xBB;
tmp[15] = 0x01;
tmp
};
// I am unsure about all the other command ids
const GET_CHARGING_CMD_ID: u8 = 3;
// const GET_MIC_CONNECTED_CMD_ID: u8 = 8;
const GET_BATTERY_CMD_ID: u8 = 2;
const GET_AUTO_SHUTDOWN_CMD_ID: u8 = 26;
const SET_AUTO_SHUTDOWN_CMD_ID: u8 = 24;
// includes also some other information such as side tone and surround sound
const GET_MUTE_CMD_ID: u8 = 1;
// const SET_MUTE_CMD_ID: u8 = 32;
// const GET_PAIRING_CMD_ID: u8 = 9;
// const GET_PRODUCT_COLOR_CMD_ID: u8 = 14;
// const GET_SIDE_TONE_ON_CMD_ID: u8 = 6;
const SET_SIDE_TONE_ON_CMD_ID: u8 = 25;
// const GET_SIDE_TONE_VOLUME_CMD_ID: u8 = 11;
// const SET_SIDE_TONE_VOLUME_CMD_ID: u8 = 35;
// const GET_VOICE_PROMPT_CMD_ID: u8 = 9;
// const SET_VOICE_PROMPT_CMD_ID: u8 = 19;
// const GET_WIRELESS_STATUS_CMD_ID: u8 = 1;
pub struct CloudIIWireless {
state: DeviceState,
}
impl CloudIIWireless {
pub fn new_from_state(state: DeviceState) -> Self {
CloudIIWireless { state }
}
pub fn new() -> Result<Self, DeviceError> {
let state = DeviceState::new(&PRODUCT_IDS, &VENDOR_IDS)?;
Ok(CloudIIWireless { state })
}
}
impl Device for CloudIIWireless {
fn get_charging_packet(&self) -> Option<Vec<u8>> {
let mut tmp = BASE_PACKET.to_vec();
tmp[15] = GET_CHARGING_CMD_ID;
Some(tmp)
}
fn get_battery_packet(&self) -> Option<Vec<u8>> {
let mut tmp = BASE_PACKET.to_vec();
tmp[15] = GET_BATTERY_CMD_ID;
Some(tmp)
}
fn set_automatic_shut_down_packet(&self, shutdown_after: Duration) -> Option<Vec<u8>> {
let mut tmp = BASE_PACKET.to_vec();
tmp[15] = SET_AUTO_SHUTDOWN_CMD_ID;
tmp[16] = (shutdown_after.as_secs() / 60) as u8;
Some(tmp)
}
fn get_automatic_shut_down_packet(&self) -> Option<Vec<u8>> {
let mut tmp = BASE_PACKET.to_vec();
tmp[15] = GET_AUTO_SHUTDOWN_CMD_ID;
Some(tmp)
}
fn get_mute_packet(&self) -> Option<Vec<u8>> {
let mut tmp = BASE_PACKET.to_vec();
tmp[15] = GET_MUTE_CMD_ID;
Some(tmp)
}
fn set_mute_packet(&self, _mute: bool) -> Option<Vec<u8>> {
None
}
fn get_mic_connected_packet(&self) -> Option<Vec<u8>> {
None
}
fn get_pairing_info_packet(&self) -> Option<Vec<u8>> {
None
}
fn get_product_color_packet(&self) -> Option<Vec<u8>> {
None
}
fn get_side_tone_packet(&self) -> Option<Vec<u8>> {
None
}
fn set_side_tone_packet(&self, side_tone_on: bool) -> Option<Vec<u8>> {
let mut tmp = BASE_PACKET.to_vec();
tmp[15] = SET_SIDE_TONE_ON_CMD_ID;
tmp[16] = side_tone_on as u8;
Some(tmp)
}
fn get_side_tone_volume_packet(&self) -> Option<Vec<u8>> {
None
}
fn set_side_tone_volume_packet(&self, _volume: u8) -> Option<Vec<u8>> {
None
}
fn get_voice_prompt_packet(&self) -> Option<Vec<u8>> {
None
}
fn set_voice_prompt_packet(&self, _enable: bool) -> Option<Vec<u8>> {
None
}
fn get_wireless_connected_status_packet(&self) -> Option<Vec<u8>> {
None
}
fn get_surround_sound_packet(&self) -> Option<Vec<u8>> {
None
}
fn set_surround_sound_packet(&self, _surround_sound: bool) -> Option<Vec<u8>> {
None
}
fn get_event_from_device_response(&self, response: &[u8]) -> Option<Vec<DeviceEvent>> {
if response.len() < 7 {
return None;
}
println!("Received packet: {:?}", response);
match (response[3], response[7], response[12], response[14]) {
(GET_BATTERY_CMD_ID, level, _, _) => Some(vec![DeviceEvent::BatterLevel(level)]),
(GET_CHARGING_CMD_ID, status, _, _) => {
Some(vec![DeviceEvent::Charging(ChargingStatus::from(status))])
}
(GET_AUTO_SHUTDOWN_CMD_ID, shutdown, _, _) => {
Some(vec![DeviceEvent::AutomaticShutdownAfter(
Duration::from_secs(shutdown as u64 * 60),
)])
}
(GET_MUTE_CMD_ID, _, surround, other) => Some(vec![
DeviceEvent::SideToneOn((other & 16) != 0),
DeviceEvent::Muted((other & 2) != 0),
DeviceEvent::SurroundSound((surround & 2) != 0),
]),
_ => {
println!("Unknown device event: {:?}", response);
None
}
}
}
fn get_device_state(&self) -> &DeviceState {
&self.state
}
fn get_device_state_mut(&mut self) -> &mut DeviceState {
&mut self.state
}
fn prepare_write(&mut self) {
let mut input_report_buffer = [0u8; 64];
input_report_buffer[0] = 6;
self.state
.hid_device
.get_input_report(&mut input_report_buffer)
.unwrap();
}
}

44
src/devices/cloud_ii_wireless_dts.rs
View File

@@ -159,35 +159,51 @@ impl Device for CloudIIWirelessDTS {
Some(tmp)
}
fn get_event_from_device_response(&self, response: &[u8]) -> Option<DeviceEvent> {
fn get_surround_sound_packet(&self) -> Option<Vec<u8>> {
None
}
fn set_surround_sound_packet(&self, _surround_sound: bool) -> Option<Vec<u8>> {
None
}
fn get_event_from_device_response(&self, response: &[u8]) -> Option<Vec<DeviceEvent>> {
if response.len() < 7 {
return None;
}
match (response[2], response[3], response[4], response[7]) {
(_, GET_CHARGING_CMD_ID, status, _) => {
Some(DeviceEvent::Charging(ChargingStatus::from(status)))
Some(vec![DeviceEvent::Charging(ChargingStatus::from(status))])
}
(_, GET_MIC_CONNECTED_CMD_ID, status, _) => {
Some(DeviceEvent::MicConnected(status == 1))
Some(vec![DeviceEvent::MicConnected(status == 1)])
}
(_, GET_BATTERY_CMD_ID, _, level) => Some(vec![DeviceEvent::BatterLevel(level)]),
(_, GET_AUTO_SHUTDOWN_CMD_ID, time, _) => {
Some(vec![DeviceEvent::AutomaticShutdownAfter(
Duration::from_secs(time as u64 * 60),
)])
}
(_, GET_BATTERY_CMD_ID, _, level) => Some(DeviceEvent::BatterLevel(level)),
(_, GET_AUTO_SHUTDOWN_CMD_ID, time, _) => Some(DeviceEvent::AutomaticShutdownAfter(
Duration::from_secs(time as u64 * 60),
)),
(_, SET_MUTE_CMD_ID, status, _) | (_, GET_MUTE_CMD_ID, status, _) => {
Some(DeviceEvent::Muted(status == 1))
Some(vec![DeviceEvent::Muted(status == 1)])
}
(_, GET_PAIRING_CMD_ID, status, _) => Some(vec![DeviceEvent::PairingInfo(status)]),
(_, GET_SIDE_TONE_ON_CMD_ID, status, _) => {
Some(vec![DeviceEvent::SideToneOn(status == 1)])
}
(_, GET_PAIRING_CMD_ID, status, _) => Some(DeviceEvent::PairingInfo(status)),
(_, GET_SIDE_TONE_ON_CMD_ID, status, _) => Some(DeviceEvent::SideToneOn(status == 1)),
(_, GET_SIDE_TONE_VOLUME_CMD_ID, status, _) => {
Some(DeviceEvent::SideToneVolume(status))
Some(vec![DeviceEvent::SideToneVolume(status)])
}
(_, GET_WIRELESS_STATUS_CMD_ID, status, _) => {
Some(DeviceEvent::WirelessConnected(status == 1 || status == 4))
Some(vec![DeviceEvent::WirelessConnected(
status == 1 || status == 4,
)])
}
(GET_VOICE_PROMPT_CMD_ID, status, _, _) => {
Some(vec![DeviceEvent::VoicePrompt(status == 1)])
}
(GET_VOICE_PROMPT_CMD_ID, status, _, _) => Some(DeviceEvent::VoicePrompt(status == 1)),
(GET_PRODUCT_COLOR_CMD_ID, status, _, _) => {
Some(DeviceEvent::ProductColor(Color::from(status)))
Some(vec![DeviceEvent::ProductColor(Color::from(status))])
}
_ => {
println!("Unknown device event: {:?}", response);

43
src/devices/mod.rs
View File

@@ -52,6 +52,7 @@ pub struct DeviceState {
pub product_color: Option<Color>,
pub side_tone_on: Option<bool>,
pub side_tone_volume: Option<u8>,
pub surround_sound: Option<bool>,
pub voice_prompt_on: Option<bool>,
pub connected: Option<bool>,
}
@@ -71,6 +72,7 @@ Pairing info: {}
Product color: {}
Side tone on: {}
Side tone volume: {}
Surround sound: {}
Voice prompt on: {}
Connected: {}",
self.device_name.clone().unwrap_or("Unknown".to_string()),
@@ -88,6 +90,8 @@ Connected: {}",
self.side_tone_on.map_or(unknown.clone(), |s| s.to_string()),
self.side_tone_volume
.map_or(unknown.clone(), |s| s.to_string()),
self.surround_sound
.map_or(unknown.clone(), |s| s.to_string()),
self.voice_prompt_on
.map_or(unknown.clone(), |v| v.to_string()),
self.connected.map_or(unknown.clone(), |c| c.to_string()),
@@ -124,6 +128,7 @@ impl DeviceState {
charging: None,
battery_level: None,
muted: None,
surround_sound: None,
mic_connected: None,
automatic_shutdown_after: None,
pairing_info: None,
@@ -147,6 +152,7 @@ Pairing info: {}
Product color: {}
Side tone on: {}
Side tone volume: {}
Surround sound: {}
Voice prompt on: {}
Connected: {}",
self.battery_level
@@ -163,6 +169,8 @@ Connected: {}",
self.side_tone_on.map_or(unknown.clone(), |s| s.to_string()),
self.side_tone_volume
.map_or(unknown.clone(), |s| s.to_string()),
self.surround_sound
.map_or(unknown.clone(), |s| s.to_string()),
self.voice_prompt_on
.map_or(unknown.clone(), |v| v.to_string()),
self.connected.map_or(unknown.clone(), |c| c.to_string()),
@@ -182,6 +190,7 @@ Connected: {}",
DeviceEvent::ProductColor(color) => self.product_color = Some(*color),
DeviceEvent::SideToneOn(side) => self.side_tone_on = Some(*side),
DeviceEvent::SideToneVolume(volume) => self.side_tone_volume = Some(*volume),
DeviceEvent::SurroundSound(status) => self.surround_sound = Some(*status),
DeviceEvent::VoicePrompt(on) => self.voice_prompt_on = Some(*on),
DeviceEvent::WirelessConnected(connected) => self.connected = Some(*connected),
};
@@ -191,7 +200,15 @@ Connected: {}",
self.charging = None;
self.battery_level = None;
self.muted = None;
self.surround_sound = None;
self.mic_connected = None;
self.automatic_shutdown_after = None;
self.pairing_info = None;
self.product_color = None;
self.side_tone_on = None;
self.side_tone_volume = None;
self.voice_prompt_on = None;
self.connected = None;
}
}
@@ -222,6 +239,7 @@ pub enum DeviceEvent {
SideToneVolume(u8),
VoicePrompt(bool),
WirelessConnected(bool),
SurroundSound(bool),
}
#[derive(Debug, Copy, Clone)]
@@ -293,6 +311,8 @@ pub trait Device {
fn get_automatic_shut_down_packet(&self) -> Option<Vec<u8>>;
fn get_mute_packet(&self) -> Option<Vec<u8>>;
fn set_mute_packet(&self, mute: bool) -> Option<Vec<u8>>;
fn get_surround_sound_packet(&self) -> Option<Vec<u8>>;
fn set_surround_sound_packet(&self, surround_sound: bool) -> Option<Vec<u8>>;
fn get_mic_connected_packet(&self) -> Option<Vec<u8>>;
fn get_pairing_info_packet(&self) -> Option<Vec<u8>>;
fn get_product_color_packet(&self) -> Option<Vec<u8>>;
@@ -303,11 +323,11 @@ pub trait Device {
fn get_voice_prompt_packet(&self) -> Option<Vec<u8>>;
fn set_voice_prompt_packet(&self, enable: bool) -> Option<Vec<u8>>;
fn get_wireless_connected_status_packet(&self) -> Option<Vec<u8>>;
fn get_event_from_device_response(&self, response: &[u8]) -> Option<DeviceEvent>;
fn get_event_from_device_response(&self, response: &[u8]) -> Option<Vec<DeviceEvent>>;
fn get_device_state(&self) -> &DeviceState;
fn get_device_state_mut(&mut self) -> &mut DeviceState;
fn prepare_write(&mut self) {}
fn wait_for_updates(&mut self, duration: Duration) -> Option<DeviceEvent> {
fn wait_for_updates(&mut self, duration: Duration) -> Option<Vec<DeviceEvent>> {
let mut buf = [0u8; 8];
let res = self
.get_device_state()
@@ -330,6 +350,7 @@ pub trait Device {
self.get_battery_packet(),
self.get_automatic_shut_down_packet(),
self.get_mute_packet(),
self.get_surround_sound_packet(),
self.get_mic_connected_packet(),
self.get_pairing_info_packet(),
self.get_product_color_packet(),
@@ -342,8 +363,10 @@ pub trait Device {
for packet in packets.into_iter().flatten() {
self.prepare_write();
self.get_device_state().hid_device.write(&packet)?;
if let Some(event) = self.wait_for_updates(Duration::from_secs(1)) {
self.get_device_state_mut().update_self_with_event(&event);
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
responded = true;
}
if !self.get_device_state().connected.map_or(true, |c| c) {
@@ -361,13 +384,17 @@ pub trait Device {
/// Refreshes the state by listening for events
/// Only the battery level is actively queried because it is not communicated by the device on its own
fn passive_refresh_state(&mut self) -> Result<(), DeviceError> {
if let Some(event) = self.wait_for_updates(Duration::from_secs(1)) {
self.get_device_state_mut().update_self_with_event(&event);
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
}
if let Some(batter_packet) = self.get_battery_packet() {
self.get_device_state().hid_device.write(&batter_packet)?;
if let Some(event) = self.wait_for_updates(Duration::from_secs(1)) {
self.get_device_state_mut().update_self_with_event(&event);
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
}
}

2
src/main.rs
View File

@@ -35,7 +35,7 @@ fn main() {
loop {
std::thread::sleep(refresh_interval);
// with the default refresh_interval the state is only actively queried every 3min
// quiting the device to frequently can lead to instability
// querying the device to frequently can lead to instability
match if run_counter % 60 == 0 {
device.active_refresh_state()
} else {