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

Remove debugging code

Browse Source
This commit is contained in:
Lennard Kittner
2025-11-08 13:13:19 +01:00
parent ebfa58d21d
commit 2f18725c11
3 changed files with 100 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/bin/hyper_headset_cli.rs
View File

@@ -77,34 +77,20 @@ fn main() {
)
.get_matches();
println!("State before doing anything");
if let Err(error) = device.active_refresh_state() {
eprintln!("{error}");
std::process::exit(1);
};
println!("{}", device.get_device_state());
if let Some(delay) = matches.get_one::<u8>("automatic_shutdown") {
println!("entering automatic_shutdown packet");
let delay = *delay as u64;
if let Some(packet) =
device.set_automatic_shut_down_packet(Duration::from_secs(delay * 60u64))
{
println!("sending automatic_shutdown packet");
device.prepare_write();
if let Err(err) = device.get_device_state().hid_device.write(&packet) {
eprintln!("Failed to set automatic shutdown with error: {:?}", err);
std::process::exit(1);
}
if let Some(events) = device.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
}
} else {
eprintln!("ERROR: Automatic shutdown is not supported on this device");
std::process::exit(1);
}
} else {
println!("not sending automatic_shutdown packet");
}
if let Some(mute) = matches.get_one::<bool>("mute") {
@@ -121,24 +107,16 @@ fn main() {
}
if let Some(enable) = matches.get_one::<bool>("enable_side_tone") {
println!("entering enable_side_tone packet");
if let Some(packet) = device.set_side_tone_packet(*enable) {
println!("sending enable_side_tone packet");
device.prepare_write();
if let Err(err) = device.get_device_state().hid_device.write(&packet) {
eprintln!("Failed to enable side tone with error: {:?}", err);
std::process::exit(1);
}
std::thread::sleep(Duration::from_millis(50));
if let Some(events) = device.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
}
} else {
eprintln!("ERROR: Side tone control is not supported on this device");
std::process::exit(1);
}
} else {
println!("not sending enable_side_tone packet");
}
if let Some(volume) = matches.get_one::<u8>("side_tone_volume") {
@@ -196,7 +174,6 @@ fn main() {
std::thread::sleep(Duration::from_secs_f64(0.5));
println!("State after potentially setting some stuff");
if let Err(error) = device.active_refresh_state() {
eprintln!("{error}");
std::process::exit(1);

213
src/devices/cloud_ii_wireless.rs
View File

@@ -170,7 +170,6 @@ impl Device for CloudIIWireless {
if response.len() < 7 {
return None;
}
println!("Received packet: {:?}", response);
// Most responses are Report ID 11 (0x0B) with structure: [11, 0, 187, cmd_id, ...]
// Some responses are Report ID 10 (0x0A) for DSP/surround status
@@ -184,27 +183,19 @@ impl Device for CloudIIWireless {
if status == 2 {
println!("Pairing mode");
}
println!("Connected: {}", connected);
Some(vec![DeviceEvent::WirelessConnected(connected)])
}
GET_BATTERY_CMD_ID => {
// Battery level is at byte 7, not byte 4
let level = response[7];
println!("Battery Level: {}%", level);
Some(vec![DeviceEvent::BatterLevel(level)])
}
GET_CHARGING_CMD_ID => {
let status = response[4];
println!(
"Charging status: {} ({:?})",
status,
ChargingStatus::from(status)
);
Some(vec![DeviceEvent::Charging(ChargingStatus::from(status))])
}
MUTE_RESPONSE_ID => {
let muted = response[4] == 1;
println!("Microphone muted: {}", muted);
Some(vec![DeviceEvent::Muted(muted)])
}
FIRMWARE_VERSION_RESPONSE_ID => {
@@ -218,12 +209,10 @@ impl Device for CloudIIWireless {
// Response format: [11, 0, 187, 25, status, ...]
// where status: 1 = enabled, 0 = disabled
let enabled = response[4] == 1;
println!("Sidetone enabled: {}", enabled);
Some(vec![DeviceEvent::SideToneOn(enabled)])
}
GET_AUTO_SHUTDOWN_CMD_ID => {
let minutes = response[4];
println!("Auto shutdown after: {} minutes", minutes);
Some(vec![DeviceEvent::AutomaticShutdownAfter(
Duration::from_secs(minutes as u64 * 60),
)])
@@ -252,10 +241,6 @@ impl Device for CloudIIWireless {
// DSP/Surround sound status response: [10, 0, dsp_status, ...]
let dsp_status = response[2];
let surround_enabled = (dsp_status & 2) == 2;
println!(
"Surround sound enabled: {} (dsp_status=0x{:02X})",
surround_enabled, dsp_status
);
Some(vec![DeviceEvent::SurroundSound(surround_enabled)])
}
_ => {
@@ -274,7 +259,6 @@ impl Device for CloudIIWireless {
}
fn prepare_write(&mut self) {
println!("Setting input report");
let mut input_report_buffer = [0u8; 64];
input_report_buffer[0] = 6;
self.state
@@ -284,104 +268,105 @@ impl Device for CloudIIWireless {
}
fn execute_headset_specific_functionality(&mut self) -> Result<(), DeviceError> {
println!("Writing special sequence");
let mut packet = [0u8; 62];
packet[0] = 6;
packet[2] = 2;
packet[4] = 154;
packet[7] = 104;
packet[8] = 74;
packet[9] = 142;
packet[10] = 10;
packet[14] = 187;
packet[15] = 1;
self.prepare_write();
println!("Writing {:?}", packet);
self.state.hid_device.write(&packet)?;
std::thread::sleep(Duration::from_millis(200));
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
}
let mut packet = [0u8; 62];
packet[0] = 6;
packet[2] = 0;
packet[4] = u8::MAX;
packet[7] = 104;
packet[8] = 74;
packet[9] = 142;
self.prepare_write();
println!("Writing {:?}", packet);
self.state.hid_device.write(&packet)?;
std::thread::sleep(Duration::from_millis(200));
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
}
let mut packet = [0u8; 62];
packet[0] = 6;
packet[2] = 2;
packet[4] = 154;
packet[7] = 104;
packet[8] = 74;
packet[9] = 142;
packet[10] = 10;
packet[14] = 187;
packet[15] = 17;
self.prepare_write();
println!("Writing {:?}", packet);
self.state.hid_device.write(&packet)?;
std::thread::sleep(Duration::from_millis(200));
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
}
let mut packet = [0u8; 62];
packet[0] = 6;
packet[2] = 2;
packet[4] = 154;
packet[7] = 104;
packet[8] = 74;
packet[9] = 142;
packet[10] = 10;
packet[14] = 187;
packet[15] = 29;
self.prepare_write();
println!("Writing {:?}", packet);
self.state.hid_device.write(&packet)?;
std::thread::sleep(Duration::from_millis(200));
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
}
let mut packet = [0u8; 62];
packet[0] = 6;
packet[2] = 2;
packet[4] = 154;
packet[7] = 104;
packet[8] = 74;
packet[9] = 142;
packet[10] = 10;
packet[14] = 187;
packet[15] = 9;
self.prepare_write();
println!("Writing {:?}", packet);
self.state.hid_device.write(&packet)?;
std::thread::sleep(Duration::from_millis(200));
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
}
//TODO: I think this unmutes the headset
// println!("Writing special sequence");
// let mut packet = [0u8; 62];
// packet[0] = 6;
// packet[2] = 2;
// packet[4] = 154;
// packet[7] = 104;
// packet[8] = 74;
// packet[9] = 142;
// packet[10] = 10;
// packet[14] = 187;
// packet[15] = 1;
// self.prepare_write();
// println!("Writing {:?}", packet);
// self.state.hid_device.write(&packet)?;
// std::thread::sleep(Duration::from_millis(200));
// if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
// println!("{:?}", events);
// for event in events {
// self.get_device_state_mut().update_self_with_event(&event);
// }
// }
// let mut packet = [0u8; 62];
// packet[0] = 6;
// packet[2] = 0;
// packet[4] = u8::MAX;
// packet[7] = 104;
// packet[8] = 74;
// packet[9] = 142;
// self.prepare_write();
// println!("Writing {:?}", packet);
// self.state.hid_device.write(&packet)?;
// std::thread::sleep(Duration::from_millis(200));
// if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
// println!("{:?}", events);
// for event in events {
// self.get_device_state_mut().update_self_with_event(&event);
// }
// }
// let mut packet = [0u8; 62];
// packet[0] = 6;
// packet[2] = 2;
// packet[4] = 154;
// packet[7] = 104;
// packet[8] = 74;
// packet[9] = 142;
// packet[10] = 10;
// packet[14] = 187;
// packet[15] = 17;
// self.prepare_write();
// println!("Writing {:?}", packet);
// self.state.hid_device.write(&packet)?;
// std::thread::sleep(Duration::from_millis(200));
// if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
// println!("{:?}", events);
// for event in events {
// self.get_device_state_mut().update_self_with_event(&event);
// }
// }
// let mut packet = [0u8; 62];
// packet[0] = 6;
// packet[2] = 2;
// packet[4] = 154;
// packet[7] = 104;
// packet[8] = 74;
// packet[9] = 142;
// packet[10] = 10;
// packet[14] = 187;
// packet[15] = 29;
// self.prepare_write();
// println!("Writing {:?}", packet);
// self.state.hid_device.write(&packet)?;
// std::thread::sleep(Duration::from_millis(200));
// if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
// println!("{:?}", events);
// for event in events {
// self.get_device_state_mut().update_self_with_event(&event);
// }
// }
// let mut packet = [0u8; 62];
// packet[0] = 6;
// packet[2] = 2;
// packet[4] = 154;
// packet[7] = 104;
// packet[8] = 74;
// packet[9] = 142;
// packet[10] = 10;
// packet[14] = 187;
// packet[15] = 9;
// self.prepare_write();
// println!("Writing {:?}", packet);
// self.state.hid_device.write(&packet)?;
// std::thread::sleep(Duration::from_millis(200));
// if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
// println!("{:?}", events);
// for event in events {
// self.get_device_state_mut().update_self_with_event(&event);
// }
// }
Ok(())
}

4
src/devices/mod.rs
View File

@@ -507,11 +507,9 @@ pub trait Device {
let mut responded = false;
for packet in packets.into_iter().flatten() {
self.prepare_write();
println!("writing Packet {packet:?}");
self.get_device_state().hid_device.write(&packet)?;
std::thread::sleep(RESPONSE_DELAY);
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
for event in events {
self.get_device_state_mut().update_self_with_event(&event);
}
@@ -532,6 +530,7 @@ 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> {
//TODO: only if the headset allows it
// println!("passive refresh");
// if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
// println!("{:?}", events);
@@ -539,7 +538,6 @@ pub trait Device {
// self.get_device_state_mut().update_self_with_event(&event);
// }
// }
println!("passive refresh get battery level");
if let Some(batter_packet) = self.get_battery_packet() {
self.prepare_write();
self.get_device_state().hid_device.write(&batter_packet)?;