force_a2dp 0.1.0

Tool to force A2DP sink on any Bluetooth device
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use std::process::Command;
use std::{thread, time};
pub struct PACMD {
    /// Mac Address e.g. AA:11:2B:3F:44:55
    pub mac: String,
    /// Sink Card e.g. bluez_card.AA_11_2B_3F_44_55
    pub sink: String,
    /// Is debug config enabled
    pub dbg: bool,
}

impl PACMD {
    /// Get all cards listed by pacmd
    pub fn get_card_list() -> String {
        let output = Command::new("pacmd")
            .arg("list-cards")
            .output()
            .expect("Failed to list cards");

        return String::from_utf8_lossy(&output.stdout).to_string();
    }

    /// Restart bluetooth connection
    pub fn restart(&self) -> bool {
        let out = Command::new("bluetoothctl")
            .arg("disconnect")
            .arg(&self.mac)
            .output()
            .expect("Failed to disconnect Bluetooth");

        let _disconnected = String::from_utf8_lossy(&out.stdout).contains("Successful disconnected");


        self.sleep(7);
        Command::new("bluetoothctl")
            .arg("connect")
            .arg(&self.mac)
            .spawn()
            .expect("Failed to connect Bluetooth");
        self.sleep(3);
        let connected = String::from_utf8_lossy(&out.stdout).contains("Connection successful");

        return connected;
    }

    fn sleep(&self, seconds: u64) {
        let ten_seconds = time::Duration::from_secs(seconds);
        thread::sleep(ten_seconds);
    }

    /// Force A2DP sink
    pub fn set_a2dp_sink(&self) -> bool {
        let out = Command::new("pacmd")
            .arg("set-card-profile")
            .arg(&self.sink)
            .arg("a2dp_sink")
            .output();

        match out {
            Ok(output) => {
                let success = output.status.success();
                if !success {
                    println!("Failed to update A2DP, restarting Bluetooth");
                    let success = self.restart();
                    if !success {
                        println!(
                            "Failed to restart {}",
                            String::from_utf8_lossy(&output.stderr)
                        );
                    } else {
                        return self.set_a2dp_sink();
                    }
                }
                success
            }
            Err(e) => {
                let success = self.restart();
                if !success {
                    println!("Failed to restart {}", e);
                } else {
                    return self.set_a2dp_sink();
                }
                success
            }
        }
    }
}