Comutați receptorul/ieșirea audio cu comanda rapidă de la tastatură

Vreau să comut între canalele/ieșirile de sunet pe Ubuntu folosind o comandă rapidă. Vreau ca soluția să funcționeze cu orice număr de dispozitive și să comute toate intrările receptorului în acest proces.

Vreau să ofer soluția mea pentru ca oricine să o folosească și să o îmbunătățească, deoarece m-a frustrat că niciuna dintre soluții (de ex. Dispozitiv de ieșire audio, comutator rapid?) a lucrat în toate condiţiile.

Astfel, am creat un script python cu puțin exagerat (și regex-uri proaste și urâte) pentru a face treaba:

#!/usr/bin/env python3
#acest mic script comută receptorul de sunet pe ubuntu
# https://askubuntu.com/questions/156895/how-to-switch-sound-output-with-key-shortcut/1203350#1203350 și https://askubuntu.com/questions/1011806/how-do-i -switch-the-audio-outputs-of-an-audio-device-from-cli?noredirect=1&lq=1 au fost utile
import argparse
jurnal de import
subproces de import
import re

#o reprezentare simplă a tuturor informațiilor relevante ale unui receptor audio pentru acest script
chiuveta clasa:
    def __init__(self, index, name, state):
        self.index = index
        self.name = nume
        self.state = stare
        dacă starea în ["RUNNING", "IDLE"]:
            self.selected = Adevărat
        altceva:
            self.selected = Fals

    def __str__(self):
        returnează „chiuveta\nindex: {self.index}\nnume: {self.name}\nstate: {self.state}\nselectat: {self.selected}\n'.format(self=self)

#o reprezentare simplă a tuturor informațiilor relevante ale unei intrări audio pentru acest script
clasa Sink_Input:
    def __init__(self, index, application_name, sink, state):
        self.index = index
        self.application_name = nume_aplicație
        self.sink = chiuveta
        self.state = stare

    def __str__(self):
        returnează 'sink-input\nindex: {self.index}\napplication_name: {self.application_name}\nsink: {self.sink}\nstate: {self.state}\n'.format(self=self)

        
def get_sinks():
    pacmd_output = str(subprocess.check_output(["pacmd", "list-sinks"]))
    sinks_raw = pacmd_output.split("index: ")
    chiuvete = []
    pentru sink_raw în sinks_raw[1:]:
        index = int(re.findall("^\d+", sink_raw)[0])
        nume = re.findall("device.description = \"[^\"]*\"", sink_raw)[0][22:-1]
        stare = re.findall("state: [A-Z]*", sink_raw)[0][7:]
        chiuvetă = chiuvetă (index, nume, stare)
        sinks.append(chiuveta)
    chiuvete de retur

def get_sink_inputs():
    sink_inputs = []
    pacmd_output = str(subprocess.check_output(["pacmd", "list-sink-inputs"]))
    inputs_raw = pacmd_output.split("index: ")
    pentru input_raw în inputs_raw[1:]:
        index = int(re.findall("^\d+", input_raw)[0])
        sink = int(re.findall("sink: \d*", input_raw)[0][5:])
        application_name = re.findall("application.name = \"[^\"]*\"", input_raw)[0][20:-1]
        stare = re.findall("stare: [A-Z]*", input_raw)[0][7:]
        sink_input = Sink_Input(index, application_name, sink, state)
        sink_inputs.append(sink_input)
    returnează sink_inputs

def switch_to_next_sink(chiuvete, notificare):
    current_sink = Nici unul
    next_sink = chiuvete[0]
    pentru eu în gamă(len(chiuvete)):
        dacă se scufundă[i].selectat:
            current_sink = chiuvete[i]
            dacă i == len(scufundă) -1:
                next_sink = chiuvete[0]
            altceva:
                next_sink = chiuvetă[i+1]
    #switch chiuveta implicită la următoarea chiuvetă
    subprocess.call(["pacmd", "set-default-sink", str(next_sink.index)])
    #mută toate aplicațiile la următoarea chiuvetă
    pentru sink_input în get_sink_inputs():
        subprocess.call(["pacmd", "move-sink-input", str(sink_input.index), str(next_sink.index)])
    daca anunta:
        subprocess.call(["notify-send", "S-a schimbat receptor audio", "noul receptor audio este " + next_sink.name])

def main():
    parser = argparse.ArgumentParser(description='''Comută la „următorul” receptor audio pe Ubuntu și poate oferi informații suplimentare despre receptorii de sunet.
    Dacă nu sunt transmise argumente, este selectat doar următorul receptor audio.
    Pentru ușurință în utilizare, adăugați /usr/bin/python3 /home/sebi/misc/switch_sound_sink.py ca scurtătură de la tastatură, adică Super+Shift+S (Super+O cumva nu funcționează) „’’)
    parser.add_argument('-s', '--state',
                        help='ieșire redusă a listelor-chiuve și a intrărilor list-sink-pacmd', action='store_true')
    parser.add_argument('-n', '--notify', help='trimite notificare pe desktop', action='store_true')
    
    logLevelsRange = [logging.NOTSET, logging.DEBUG, logging.INFO, logging.WARN, logging.ERROR, logging.CRITICAL]
    parser.add_argument('-l', '--logLevel', help='nivelul jurnalului', type=int, choices=logLevelsRange,
                        default=logging.INFO)

    args = parser.parse_args()

    dacă args.state:
        chiuvete = get_sinks()
        pentru chiuveta in chiuvete:
            imprimare (chiuveta)
        sink_inputs = get_sink_inputs()
        pentru sink_input în sink_inputs:
            imprimare(sink_input)
    altceva:
        chiuvete = get_sinks()
        switch_to_next_sink(chiuvete, args.notify)
        
principal()

Am adăugat notificări opționale pentru desktop, dar nu le utilizați, deoarece nu pot fi afișate doar temporar. (Cum pot trimite o notificare personalizată pentru desktop?)