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(); .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") { if let Some(delay) = matches.get_one::<u8>("automatic_shutdown") {
println!("entering automatic_shutdown packet");
let delay = *delay as u64; let delay = *delay as u64;
if let Some(packet) = if let Some(packet) =
device.set_automatic_shut_down_packet(Duration::from_secs(delay * 60u64)) device.set_automatic_shut_down_packet(Duration::from_secs(delay * 60u64))
{ {
println!("sending automatic_shutdown packet");
device.prepare_write(); device.prepare_write();
if let Err(err) = device.get_device_state().hid_device.write(&packet) { if let Err(err) = device.get_device_state().hid_device.write(&packet) {
eprintln!("Failed to set automatic shutdown with error: {:?}", err); eprintln!("Failed to set automatic shutdown with error: {:?}", err);
std::process::exit(1); std::process::exit(1);
} }
if let Some(events) = device.wait_for_updates(Duration::from_secs(1)) {
println!("{:?}", events);
}
} else { } else {
eprintln!("ERROR: Automatic shutdown is not supported on this device"); eprintln!("ERROR: Automatic shutdown is not supported on this device");
std::process::exit(1); std::process::exit(1);
} }
} else {
println!("not sending automatic_shutdown packet");
} }
if let Some(mute) = matches.get_one::<bool>("mute") { 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") { 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) { if let Some(packet) = device.set_side_tone_packet(*enable) {
println!("sending enable_side_tone packet");
device.prepare_write(); device.prepare_write();
if let Err(err) = device.get_device_state().hid_device.write(&packet) { if let Err(err) = device.get_device_state().hid_device.write(&packet) {
eprintln!("Failed to enable side tone with error: {:?}", err); eprintln!("Failed to enable side tone with error: {:?}", err);
std::process::exit(1); 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 { } else {
eprintln!("ERROR: Side tone control is not supported on this device"); eprintln!("ERROR: Side tone control is not supported on this device");
std::process::exit(1); std::process::exit(1);
} }
} else {
println!("not sending enable_side_tone packet");
} }
if let Some(volume) = matches.get_one::<u8>("side_tone_volume") { 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)); std::thread::sleep(Duration::from_secs_f64(0.5));
println!("State after potentially setting some stuff");
if let Err(error) = device.active_refresh_state() { if let Err(error) = device.active_refresh_state() {
eprintln!("{error}"); eprintln!("{error}");
std::process::exit(1); 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 { if response.len() < 7 {
return None; return None;
} }
println!("Received packet: {:?}", response);
// Most responses are Report ID 11 (0x0B) with structure: [11, 0, 187, cmd_id, ...] // 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 // Some responses are Report ID 10 (0x0A) for DSP/surround status
@@ -184,27 +183,19 @@ impl Device for CloudIIWireless {
if status == 2 { if status == 2 {
println!("Pairing mode"); println!("Pairing mode");
} }
println!("Connected: {}", connected);
Some(vec![DeviceEvent::WirelessConnected(connected)]) Some(vec![DeviceEvent::WirelessConnected(connected)])
} }
GET_BATTERY_CMD_ID => { GET_BATTERY_CMD_ID => {
// Battery level is at byte 7, not byte 4 // Battery level is at byte 7, not byte 4
let level = response[7]; let level = response[7];
println!("Battery Level: {}%", level);
Some(vec![DeviceEvent::BatterLevel(level)]) Some(vec![DeviceEvent::BatterLevel(level)])
} }
GET_CHARGING_CMD_ID => { GET_CHARGING_CMD_ID => {
let status = response[4]; let status = response[4];
println!(
"Charging status: {} ({:?})",
status,
ChargingStatus::from(status)
);
Some(vec![DeviceEvent::Charging(ChargingStatus::from(status))]) Some(vec![DeviceEvent::Charging(ChargingStatus::from(status))])
} }
MUTE_RESPONSE_ID => { MUTE_RESPONSE_ID => {
let muted = response[4] == 1; let muted = response[4] == 1;
println!("Microphone muted: {}", muted);
Some(vec![DeviceEvent::Muted(muted)]) Some(vec![DeviceEvent::Muted(muted)])
} }
FIRMWARE_VERSION_RESPONSE_ID => { FIRMWARE_VERSION_RESPONSE_ID => {
@@ -218,12 +209,10 @@ impl Device for CloudIIWireless {
// Response format: [11, 0, 187, 25, status, ...] // Response format: [11, 0, 187, 25, status, ...]
// where status: 1 = enabled, 0 = disabled // where status: 1 = enabled, 0 = disabled
let enabled = response[4] == 1; let enabled = response[4] == 1;
println!("Sidetone enabled: {}", enabled);
Some(vec![DeviceEvent::SideToneOn(enabled)]) Some(vec![DeviceEvent::SideToneOn(enabled)])
} }
GET_AUTO_SHUTDOWN_CMD_ID => { GET_AUTO_SHUTDOWN_CMD_ID => {
let minutes = response[4]; let minutes = response[4];
println!("Auto shutdown after: {} minutes", minutes);
Some(vec![DeviceEvent::AutomaticShutdownAfter( Some(vec![DeviceEvent::AutomaticShutdownAfter(
Duration::from_secs(minutes as u64 * 60), Duration::from_secs(minutes as u64 * 60),
)]) )])
@@ -252,10 +241,6 @@ impl Device for CloudIIWireless {
// DSP/Surround sound status response: [10, 0, dsp_status, ...] // DSP/Surround sound status response: [10, 0, dsp_status, ...]
let dsp_status = response[2]; let dsp_status = response[2];
let surround_enabled = (dsp_status & 2) == 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)]) Some(vec![DeviceEvent::SurroundSound(surround_enabled)])
} }
_ => { _ => {
@@ -274,7 +259,6 @@ impl Device for CloudIIWireless {
} }
fn prepare_write(&mut self) { fn prepare_write(&mut self) {
println!("Setting input report");
let mut input_report_buffer = [0u8; 64]; let mut input_report_buffer = [0u8; 64];
input_report_buffer[0] = 6; input_report_buffer[0] = 6;
self.state self.state
@@ -284,104 +268,105 @@ impl Device for CloudIIWireless {
} }
fn execute_headset_specific_functionality(&mut self) -> Result<(), DeviceError> { fn execute_headset_specific_functionality(&mut self) -> Result<(), DeviceError> {
println!("Writing special sequence"); //TODO: I think this unmutes the headset
let mut packet = [0u8; 62]; // println!("Writing special sequence");
packet[0] = 6; // let mut packet = [0u8; 62];
packet[2] = 2; // packet[0] = 6;
packet[4] = 154; // packet[2] = 2;
packet[7] = 104; // packet[4] = 154;
packet[8] = 74; // packet[7] = 104;
packet[9] = 142; // packet[8] = 74;
packet[10] = 10; // packet[9] = 142;
packet[14] = 187; // packet[10] = 10;
packet[15] = 1; // packet[14] = 187;
self.prepare_write(); // packet[15] = 1;
println!("Writing {:?}", packet); // self.prepare_write();
self.state.hid_device.write(&packet)?; // println!("Writing {:?}", packet);
std::thread::sleep(Duration::from_millis(200)); // self.state.hid_device.write(&packet)?;
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) { // std::thread::sleep(Duration::from_millis(200));
println!("{:?}", events); // if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events { // println!("{:?}", events);
self.get_device_state_mut().update_self_with_event(&event); // for event in events {
} // self.get_device_state_mut().update_self_with_event(&event);
} // }
let mut packet = [0u8; 62]; // }
packet[0] = 6; // let mut packet = [0u8; 62];
packet[2] = 0; // packet[0] = 6;
packet[4] = u8::MAX; // packet[2] = 0;
packet[7] = 104; // packet[4] = u8::MAX;
packet[8] = 74; // packet[7] = 104;
packet[9] = 142; // packet[8] = 74;
self.prepare_write(); // packet[9] = 142;
println!("Writing {:?}", packet); // self.prepare_write();
self.state.hid_device.write(&packet)?; // println!("Writing {:?}", packet);
std::thread::sleep(Duration::from_millis(200)); // self.state.hid_device.write(&packet)?;
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) { // std::thread::sleep(Duration::from_millis(200));
println!("{:?}", events); // if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events { // println!("{:?}", events);
self.get_device_state_mut().update_self_with_event(&event); // for event in events {
} // self.get_device_state_mut().update_self_with_event(&event);
} // }
let mut packet = [0u8; 62]; // }
packet[0] = 6; // let mut packet = [0u8; 62];
packet[2] = 2; // packet[0] = 6;
packet[4] = 154; // packet[2] = 2;
packet[7] = 104; // packet[4] = 154;
packet[8] = 74; // packet[7] = 104;
packet[9] = 142; // packet[8] = 74;
packet[10] = 10; // packet[9] = 142;
packet[14] = 187; // packet[10] = 10;
packet[15] = 17; // packet[14] = 187;
self.prepare_write(); // packet[15] = 17;
println!("Writing {:?}", packet); // self.prepare_write();
self.state.hid_device.write(&packet)?; // println!("Writing {:?}", packet);
std::thread::sleep(Duration::from_millis(200)); // self.state.hid_device.write(&packet)?;
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) { // std::thread::sleep(Duration::from_millis(200));
println!("{:?}", events); // if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events { // println!("{:?}", events);
self.get_device_state_mut().update_self_with_event(&event); // for event in events {
} // self.get_device_state_mut().update_self_with_event(&event);
} // }
let mut packet = [0u8; 62]; // }
packet[0] = 6; // let mut packet = [0u8; 62];
packet[2] = 2; // packet[0] = 6;
packet[4] = 154; // packet[2] = 2;
packet[7] = 104; // packet[4] = 154;
packet[8] = 74; // packet[7] = 104;
packet[9] = 142; // packet[8] = 74;
packet[10] = 10; // packet[9] = 142;
packet[14] = 187; // packet[10] = 10;
packet[15] = 29; // packet[14] = 187;
self.prepare_write(); // packet[15] = 29;
println!("Writing {:?}", packet); // self.prepare_write();
self.state.hid_device.write(&packet)?; // println!("Writing {:?}", packet);
std::thread::sleep(Duration::from_millis(200)); // self.state.hid_device.write(&packet)?;
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) { // std::thread::sleep(Duration::from_millis(200));
println!("{:?}", events); // if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events { // println!("{:?}", events);
self.get_device_state_mut().update_self_with_event(&event); // for event in events {
} // self.get_device_state_mut().update_self_with_event(&event);
} // }
let mut packet = [0u8; 62]; // }
packet[0] = 6; // let mut packet = [0u8; 62];
packet[2] = 2; // packet[0] = 6;
packet[4] = 154; // packet[2] = 2;
packet[7] = 104; // packet[4] = 154;
packet[8] = 74; // packet[7] = 104;
packet[9] = 142; // packet[8] = 74;
packet[10] = 10; // packet[9] = 142;
packet[14] = 187; // packet[10] = 10;
packet[15] = 9; // packet[14] = 187;
self.prepare_write(); // packet[15] = 9;
println!("Writing {:?}", packet); // self.prepare_write();
self.state.hid_device.write(&packet)?; // println!("Writing {:?}", packet);
std::thread::sleep(Duration::from_millis(200)); // self.state.hid_device.write(&packet)?;
if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) { // std::thread::sleep(Duration::from_millis(200));
println!("{:?}", events); // if let Some(events) = self.wait_for_updates(Duration::from_secs(1)) {
for event in events { // println!("{:?}", events);
self.get_device_state_mut().update_self_with_event(&event); // for event in events {
} // self.get_device_state_mut().update_self_with_event(&event);
} // }
// }
Ok(()) Ok(())
} }

4
src/devices/mod.rs
View File

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