mirror of
https://github.com/AvengeMedia/DankMaterialShell.git
synced 2026-10-17 00:34:01 -04:00
1446 lines
48 KiB
QML
1446 lines
48 KiB
QML
pragma Singleton
|
|
pragma ComponentBehavior: Bound
|
|
|
|
import QtCore
|
|
import QtQuick
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import Quickshell.Services.Pipewire
|
|
import qs.Common
|
|
import qs.Services
|
|
import "../Common/GSettings.js" as GSettings
|
|
|
|
Singleton {
|
|
id: root
|
|
readonly property var log: Log.scoped("AudioService")
|
|
|
|
readonly property PwNode sink: Pipewire.defaultAudioSink
|
|
readonly property PwNode source: Pipewire.defaultAudioSource
|
|
|
|
readonly property bool soundsAvailable: MultimediaService.available
|
|
property bool playersRequested: false
|
|
property bool soundThemeSupported: false
|
|
property bool soundThemeResolved: false
|
|
property bool loginSoundPending: false
|
|
property var availableSoundThemes: []
|
|
property string currentSoundTheme: ""
|
|
property var soundFilePaths: ({})
|
|
|
|
readonly property var volumeChangeSound: soundsLoader.item?.volumeChangeSound ?? null
|
|
readonly property var powerPlugSound: soundsLoader.item?.powerPlugSound ?? null
|
|
readonly property var powerUnplugSound: soundsLoader.item?.powerUnplugSound ?? null
|
|
readonly property var normalNotificationSound: soundsLoader.item?.normalNotificationSound ?? null
|
|
readonly property var criticalNotificationSound: soundsLoader.item?.criticalNotificationSound ?? null
|
|
readonly property var loginSound: soundsLoader.item?.loginSound ?? null
|
|
readonly property var mediaDevices: soundsLoader.item?.mediaDevices ?? null
|
|
property real notificationsVolume: 1.0
|
|
property bool notificationsAudioMuted: false
|
|
|
|
Loader {
|
|
id: soundsLoader
|
|
active: root.playersRequested && root.soundsAvailable
|
|
source: "AudioSoundPlayers.qml"
|
|
}
|
|
|
|
property var deviceAliases: ({})
|
|
property string wireplumberConfigPath: Paths.strip(StandardPaths.writableLocation(StandardPaths.ConfigLocation)) + "/wireplumber/wireplumber.conf.d/51-dms-audio-aliases.conf"
|
|
property bool wireplumberReloading: false
|
|
|
|
property var sinkPorts: ({})
|
|
property var cards: []
|
|
property var pendingCardSwitch: null
|
|
readonly property var switchableOutputPorts: root.collectSwitchableOutputPorts(root.cards, SessionData.hiddenOutputDeviceNames ?? [])
|
|
|
|
readonly property int sinkMaxVolume: {
|
|
const name = sink?.name ?? "";
|
|
if (!name)
|
|
return 100;
|
|
return SessionData.deviceMaxVolumes[name] ?? 100;
|
|
}
|
|
|
|
readonly property int sinkVolumePercent: Math.min(sinkMaxVolume, Math.round((sink?.audio?.volume ?? 0) * 100))
|
|
readonly property int sourceVolumePercent: Math.round((source?.audio?.volume ?? 0) * 100)
|
|
readonly property int wheelVolumeStep: SettingsData.audioWheelScrollAmount
|
|
|
|
signal micMuteChanged
|
|
signal micVolumeChanged
|
|
signal audioOutputCycled(string deviceName, string deviceIcon)
|
|
signal deviceAliasChanged(string nodeName, string newAlias)
|
|
signal wireplumberReloadStarted
|
|
signal wireplumberReloadCompleted(bool success)
|
|
|
|
function getMaxVolumePercent(node) {
|
|
if (!node?.name)
|
|
return 100;
|
|
return SessionData.deviceMaxVolumes[node.name] ?? 100;
|
|
}
|
|
|
|
Connections {
|
|
target: SessionData
|
|
function onDeviceMaxVolumesChanged() {
|
|
if (!root.sink?.audio)
|
|
return;
|
|
const maxVol = root.sinkMaxVolume;
|
|
const currentPercent = Math.round(root.sink.audio.volume * 100);
|
|
if (currentPercent > maxVol)
|
|
root.sink.audio.volume = maxVol / 100;
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: loginSoundChecker
|
|
onExited: exitCode => {
|
|
if (exitCode === 0) {
|
|
playLoginSound();
|
|
}
|
|
}
|
|
}
|
|
|
|
function getAvailableSinks() {
|
|
const hidden = SessionData.hiddenOutputDeviceNames ?? [];
|
|
return Pipewire.nodes.values.filter(node => node.audio && node.isSink && (SettingsData.audioShowStreamDevices || !node.isStream) && !hidden.includes(node.name));
|
|
}
|
|
|
|
property list<PwNode> typedSinks: []
|
|
property list<PwNode> typedSources: []
|
|
|
|
function rebuildTypedNodeLists() {
|
|
const newSinks = [];
|
|
const newSources = [];
|
|
for (const node of Pipewire.nodes.values) {
|
|
if (!node?.audio || (node.isStream && !SettingsData.audioShowStreamDevices))
|
|
continue;
|
|
if (node.isSink)
|
|
newSinks.push(node);
|
|
else
|
|
newSources.push(node);
|
|
}
|
|
typedSinks = newSinks;
|
|
typedSources = newSources;
|
|
}
|
|
|
|
Connections {
|
|
target: Pipewire.nodes
|
|
function onValuesChanged() {
|
|
root.rebuildTypedNodeLists();
|
|
root.adoptPendingCardSink();
|
|
}
|
|
}
|
|
|
|
Connections {
|
|
target: SettingsData
|
|
function onAudioShowStreamDevicesChanged() {
|
|
root.rebuildTypedNodeLists();
|
|
}
|
|
}
|
|
|
|
function setSink(node: PwNode): bool {
|
|
if (!node)
|
|
return false;
|
|
Pipewire.preferredDefaultAudioSink = node;
|
|
return true;
|
|
}
|
|
|
|
function setSource(node: PwNode): bool {
|
|
if (!node)
|
|
return false;
|
|
Pipewire.preferredDefaultAudioSource = node;
|
|
return true;
|
|
}
|
|
|
|
function setDefaultSinkByName(name) {
|
|
if (!name)
|
|
return false;
|
|
for (const node of typedSinks) {
|
|
if (node?.name === name)
|
|
return setSink(node);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function setDefaultSourceByName(name) {
|
|
if (!name)
|
|
return false;
|
|
for (const node of typedSources) {
|
|
if (node?.name === name)
|
|
return setSource(node);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function refreshSinkPorts(callback) {
|
|
// ensure that parsed labels are in English
|
|
Proc.runCommand("audio-list-sink-ports", ["env", "LC_ALL=C", "pactl", "list", "sinks"], (output, exitCode) => {
|
|
if (exitCode === 0)
|
|
root.sinkPorts = root.parseSinkPorts(output);
|
|
if (callback)
|
|
callback();
|
|
}, 0);
|
|
}
|
|
|
|
function getSinkPorts(node) {
|
|
return sinkPorts[node?.name] ?? null;
|
|
}
|
|
|
|
function sinkHasMultiplePorts(node) {
|
|
return (sinkPorts[node?.name]?.ports?.length ?? 0) > 1;
|
|
}
|
|
|
|
function setSinkPort(sinkName, portName, callback) {
|
|
Proc.runCommand("audio-set-sink-port", ["env", "LC_ALL=C", "pactl", "set-sink-port", sinkName, portName], (output, exitCode) => {
|
|
const ok = exitCode === 0;
|
|
if (callback)
|
|
callback(ok, ok ? I18n.tr("Port switched", "audio sink port switched successful message") : (output || I18n.tr("Failed to switch port", "audio sink port switch failure message")));
|
|
if (ok)
|
|
Qt.callLater(() => root.refreshSinkPorts());
|
|
}, 0);
|
|
}
|
|
|
|
function parseSinkPorts(text) {
|
|
const result = {};
|
|
const lines = (text || "").split("\n");
|
|
let current = null;
|
|
let inPorts = false;
|
|
|
|
function commit() {
|
|
if (current && current.name)
|
|
result[current.name] = {
|
|
active: current.active,
|
|
ports: current.ports
|
|
};
|
|
}
|
|
|
|
for (const rawLine of lines) {
|
|
const line = rawLine.trim();
|
|
|
|
if (/^Sink #\d+/.test(line)) {
|
|
commit();
|
|
current = {
|
|
name: null,
|
|
active: "",
|
|
ports: []
|
|
};
|
|
inPorts = false;
|
|
continue;
|
|
}
|
|
|
|
if (!current)
|
|
continue;
|
|
|
|
if (line.startsWith("Name:")) {
|
|
current.name = line.substring(5).trim();
|
|
inPorts = false;
|
|
continue;
|
|
}
|
|
|
|
if (line === "Ports:") {
|
|
inPorts = true;
|
|
continue;
|
|
}
|
|
|
|
if (line.startsWith("Active Port:")) {
|
|
current.active = line.substring(12).trim();
|
|
inPorts = false;
|
|
continue;
|
|
}
|
|
|
|
if (inPorts) {
|
|
// name up to first ": ", meta is the trailing "(...)", description is whatever's in between
|
|
const match = line.match(/^(.+?):\s+(.*)\s+\(([^()]*)\)$/);
|
|
if (!match)
|
|
continue;
|
|
const meta = match[3];
|
|
let availability = "unknown";
|
|
if (meta.includes("not available"))
|
|
availability = "no";
|
|
else if (/\bavailable\b/.test(meta))
|
|
availability = "yes";
|
|
current.ports.push({
|
|
name: match[1],
|
|
description: match[2],
|
|
availability: availability,
|
|
priority: parseInt(meta.match(/priority:?\s*(\d+)/)?.[1] ?? "0", 10)
|
|
});
|
|
}
|
|
}
|
|
|
|
commit();
|
|
return result;
|
|
}
|
|
|
|
function refreshCards(callback) {
|
|
Proc.runCommand("audio-list-cards", ["env", "LC_ALL=C", "pactl", "list", "cards"], (output, exitCode) => {
|
|
root.cards = exitCode === 0 ? root.parseCards(output) : [];
|
|
if (callback)
|
|
callback();
|
|
}, 0);
|
|
}
|
|
|
|
function parseCards(text) {
|
|
const cards = [];
|
|
let card = null;
|
|
let port = null;
|
|
let section = "";
|
|
|
|
function commit() {
|
|
if (!card?.name)
|
|
return;
|
|
const props = card.props;
|
|
card.description = props["device.description"] || props["device.nick"] || props["alsa.card_name"] || card.name;
|
|
cards.push(card);
|
|
}
|
|
|
|
function applyProperty(target, line) {
|
|
const match = line.match(/^([^=\s]+)\s*=\s*"(.*)"$/);
|
|
if (match)
|
|
target[match[1]] = match[2];
|
|
}
|
|
|
|
function addProfile(target, line) {
|
|
const match = line.match(/^(.+?):\s+(.*)\s+\(([^()]*)\)$/);
|
|
if (!match)
|
|
return;
|
|
const meta = match[3];
|
|
target.profiles[match[1]] = {
|
|
description: match[2],
|
|
priority: parseInt(meta.match(/priority:?\s*(\d+)/)?.[1] ?? "0", 10),
|
|
available: !/available:\s*no/.test(meta)
|
|
};
|
|
}
|
|
|
|
function addPort(target, line) {
|
|
const match = line.match(/^(.+?):\s+(.*)\s+\(([^()]*)\)$/);
|
|
if (!match)
|
|
return null;
|
|
const meta = match[3];
|
|
let availability = "unknown";
|
|
if (meta.includes("not available"))
|
|
availability = "no";
|
|
else if (/\bavailable\b/.test(meta))
|
|
availability = "yes";
|
|
const entry = {
|
|
name: match[1],
|
|
description: match[2],
|
|
type: (meta.match(/type:\s*([^,]+)/)?.[1] ?? "").trim().toLowerCase(),
|
|
availability: availability,
|
|
profiles: [],
|
|
props: {}
|
|
};
|
|
target.ports.push(entry);
|
|
return entry;
|
|
}
|
|
|
|
for (const rawLine of (text || "").split("\n")) {
|
|
const line = rawLine.trim();
|
|
|
|
if (/^Card #\d+/.test(line)) {
|
|
commit();
|
|
card = {
|
|
name: "",
|
|
description: "",
|
|
activeProfile: "",
|
|
profiles: {},
|
|
ports: [],
|
|
props: {}
|
|
};
|
|
port = null;
|
|
section = "";
|
|
continue;
|
|
}
|
|
|
|
if (!card)
|
|
continue;
|
|
|
|
if (line.startsWith("Name:")) {
|
|
card.name = line.substring(5).trim();
|
|
section = "";
|
|
continue;
|
|
}
|
|
if (line === "Properties:") {
|
|
section = port ? "portProps" : "cardProps";
|
|
continue;
|
|
}
|
|
if (line === "Profiles:") {
|
|
section = "profiles";
|
|
continue;
|
|
}
|
|
if (line === "Ports:") {
|
|
section = "ports";
|
|
continue;
|
|
}
|
|
if (line.startsWith("Active Profile:")) {
|
|
card.activeProfile = line.substring(15).trim();
|
|
section = "";
|
|
continue;
|
|
}
|
|
if (line.startsWith("Part of profile(s):")) {
|
|
if (port)
|
|
port.profiles = line.substring(19).split(",").map(s => s.trim()).filter(s => s);
|
|
section = "ports";
|
|
continue;
|
|
}
|
|
|
|
switch (section) {
|
|
case "cardProps":
|
|
applyProperty(card.props, line);
|
|
break;
|
|
case "portProps":
|
|
if (port)
|
|
applyProperty(port.props, line);
|
|
break;
|
|
case "profiles":
|
|
addProfile(card, line);
|
|
break;
|
|
case "ports":
|
|
port = addPort(card, line) ?? port;
|
|
break;
|
|
}
|
|
}
|
|
|
|
commit();
|
|
return cards;
|
|
}
|
|
|
|
function bestOutputProfile(card, port) {
|
|
const candidates = port.profiles.filter(name => name.startsWith("output:") && card.profiles[name]?.available);
|
|
if (candidates.length === 0)
|
|
return "";
|
|
candidates.sort((a, b) => card.profiles[b].priority - card.profiles[a].priority);
|
|
return candidates[0];
|
|
}
|
|
|
|
function profileSinkNames(cardName, profile) {
|
|
if (!cardName.startsWith("alsa_card."))
|
|
return [];
|
|
const prefix = "alsa_output." + cardName.substring(10) + ".";
|
|
return profile.split("+").filter(part => part.startsWith("output:")).map(part => prefix + part.substring(7));
|
|
}
|
|
|
|
function collectSwitchableOutputPorts(cards, hiddenSinkNames) {
|
|
const entries = [];
|
|
for (const card of cards || []) {
|
|
if (!card.activeProfile || card.activeProfile === "pro-audio")
|
|
continue;
|
|
for (const port of card.ports) {
|
|
if (port.availability === "no" || port.profiles.includes(card.activeProfile))
|
|
continue;
|
|
if (port.profiles.some(name => name.startsWith("input:")))
|
|
continue;
|
|
const profile = bestOutputProfile(card, port);
|
|
if (!profile)
|
|
continue;
|
|
if (profileSinkNames(card.name, profile).some(name => hiddenSinkNames.includes(name)))
|
|
continue;
|
|
const product = port.props["device.product.name"] || "";
|
|
entries.push({
|
|
cardName: card.name,
|
|
cardDescription: card.description,
|
|
portName: port.name,
|
|
profile: profile,
|
|
icon: port.type === "hdmi" ? "tv" : "speaker",
|
|
title: product ? `${port.description} [${product}]` : port.description
|
|
});
|
|
}
|
|
}
|
|
return entries;
|
|
}
|
|
|
|
function sinkBelongsToCard(node, cardName) {
|
|
if (!node || node.isStream || !cardName)
|
|
return false;
|
|
if (node.properties?.["device.name"] === cardName)
|
|
return true;
|
|
if (!cardName.startsWith("alsa_card."))
|
|
return false;
|
|
return (node.name || "").startsWith("alsa_output." + cardName.substring(10) + ".");
|
|
}
|
|
|
|
function activateOutputPort(entry, callback) {
|
|
if (!entry?.cardName || !entry.profile)
|
|
return;
|
|
const previousSinks = Pipewire.nodes.values.filter(n => n.isSink && sinkBelongsToCard(n, entry.cardName)).map(n => n.name);
|
|
Proc.runCommand("audio-set-card-profile", ["env", "LC_ALL=C", "pactl", "set-card-profile", entry.cardName, entry.profile], (output, exitCode) => {
|
|
const ok = exitCode === 0;
|
|
if (ok) {
|
|
root.pendingCardSwitch = {
|
|
cardName: entry.cardName,
|
|
portName: entry.portName,
|
|
exclude: previousSinks
|
|
};
|
|
pendingCardSwitchTimer.restart();
|
|
root.adoptPendingCardSink();
|
|
}
|
|
if (callback)
|
|
callback(ok, ok ? I18n.tr("Output switched", "audio card profile switched successful message") : (output || I18n.tr("Failed to switch output", "audio card profile switch failure message")));
|
|
Qt.callLater(() => {
|
|
root.refreshCards();
|
|
root.refreshSinkPorts();
|
|
});
|
|
}, 0);
|
|
}
|
|
|
|
function adoptPendingCardSink() {
|
|
const pending = pendingCardSwitch;
|
|
if (!pending)
|
|
return;
|
|
const node = Pipewire.nodes.values.find(n => n.isSink && sinkBelongsToCard(n, pending.cardName) && !pending.exclude.includes(n.name));
|
|
if (!node)
|
|
return;
|
|
pendingCardSwitch = null;
|
|
pendingCardSwitchTimer.stop();
|
|
setSink(node);
|
|
setSinkPort(node.name, pending.portName);
|
|
}
|
|
|
|
Timer {
|
|
id: pendingCardSwitchTimer
|
|
interval: 5000
|
|
onTriggered: root.pendingCardSwitch = null
|
|
}
|
|
|
|
function cycleAudioOutputDirection(forward) {
|
|
const sinks = getAvailableSinks();
|
|
if (sinks.length < 2)
|
|
return null;
|
|
|
|
const currentName = root.sink?.name ?? "";
|
|
const currentIndex = sinks.findIndex(s => s.name === currentName);
|
|
let nextIndex;
|
|
if (forward) {
|
|
nextIndex = (currentIndex + 1) % sinks.length;
|
|
} else {
|
|
nextIndex = (currentIndex - 1 + sinks.length) % sinks.length;
|
|
}
|
|
const nextSink = sinks[nextIndex];
|
|
setDefaultSinkByName(nextSink.name);
|
|
const name = displayName(nextSink);
|
|
audioOutputCycled(name, sinkIcon(nextSink));
|
|
return name;
|
|
}
|
|
|
|
function cycleAudioOutput() {
|
|
return cycleAudioOutputDirection(true);
|
|
}
|
|
|
|
function getDeviceAlias(nodeName) {
|
|
if (!nodeName)
|
|
return null;
|
|
return deviceAliases[nodeName] || null;
|
|
}
|
|
|
|
function hasDeviceAlias(nodeName) {
|
|
if (!nodeName)
|
|
return false;
|
|
return deviceAliases.hasOwnProperty(nodeName) && deviceAliases[nodeName] !== null && deviceAliases[nodeName] !== "";
|
|
}
|
|
|
|
function setDeviceAlias(nodeName, customAlias) {
|
|
if (!nodeName) {
|
|
log.error("Cannot set alias - nodeName is empty");
|
|
return false;
|
|
}
|
|
|
|
if (!customAlias || customAlias.trim() === "") {
|
|
return removeDeviceAlias(nodeName);
|
|
}
|
|
|
|
const trimmedAlias = customAlias.trim();
|
|
|
|
const updated = Object.assign({}, deviceAliases);
|
|
updated[nodeName] = trimmedAlias;
|
|
deviceAliases = updated;
|
|
|
|
const btDevice = BluetoothService.deviceForNodeName(nodeName);
|
|
if (btDevice)
|
|
btDevice.name = trimmedAlias;
|
|
|
|
writeWireplumberConfig();
|
|
deviceAliasChanged(nodeName, trimmedAlias);
|
|
return true;
|
|
}
|
|
|
|
function removeDeviceAlias(nodeName) {
|
|
if (!nodeName)
|
|
return false;
|
|
|
|
if (!hasDeviceAlias(nodeName))
|
|
return false;
|
|
|
|
const updated = Object.assign({}, deviceAliases);
|
|
delete updated[nodeName];
|
|
deviceAliases = updated;
|
|
|
|
// Empty BlueZ alias write resets to the device's real name.
|
|
const btDevice = BluetoothService.deviceForNodeName(nodeName);
|
|
if (btDevice)
|
|
btDevice.name = "";
|
|
|
|
writeWireplumberConfig();
|
|
deviceAliasChanged(nodeName, "");
|
|
return true;
|
|
}
|
|
|
|
function writeWireplumberConfig() {
|
|
const configDir = Paths.strip(StandardPaths.writableLocation(StandardPaths.ConfigLocation)) + "/wireplumber/wireplumber.conf.d";
|
|
const configContent = generateWireplumberConfig();
|
|
|
|
const shellCmd = `mkdir -p "${configDir}" && cat > "${wireplumberConfigPath}" << 'EOFCONFIG'
|
|
${configContent}
|
|
EOFCONFIG
|
|
`;
|
|
|
|
Proc.runCommand("writeWireplumberConfig", ["sh", "-c", shellCmd], (output, exitCode) => {
|
|
if (exitCode !== 0) {
|
|
log.error("Failed to write WirePlumber config. Exit code:", exitCode);
|
|
log.error("Error output:", output);
|
|
ToastService.showError(I18n.tr("Failed to save audio config"), output || "");
|
|
return;
|
|
}
|
|
|
|
reloadWireplumberConfig();
|
|
}, 0);
|
|
}
|
|
|
|
function generateWireplumberConfig() {
|
|
let config = "# Generated by DankMaterialShell - Audio Device Aliases\n";
|
|
config += "# Do not edit manually - changes will be overwritten\n";
|
|
config += "# Last updated: " + new Date().toISOString() + "\n\n";
|
|
|
|
const aliasKeys = Object.keys(deviceAliases);
|
|
if (aliasKeys.length === 0) {
|
|
config += "# No device aliases configured\n";
|
|
return config;
|
|
}
|
|
|
|
const alsaAliases = [];
|
|
const bluezAliases = [];
|
|
const otherAliases = [];
|
|
|
|
for (const nodeName of aliasKeys) {
|
|
const alias = deviceAliases[nodeName];
|
|
if (!alias)
|
|
continue;
|
|
|
|
const rule = {
|
|
nodeName: nodeName,
|
|
alias: alias
|
|
};
|
|
|
|
if (nodeName.includes("alsa")) {
|
|
alsaAliases.push(rule);
|
|
} else if (nodeName.includes("bluez")) {
|
|
bluezAliases.push(rule);
|
|
} else {
|
|
otherAliases.push(rule);
|
|
}
|
|
}
|
|
|
|
if (alsaAliases.length > 0) {
|
|
config += "monitor.alsa.rules = [\n";
|
|
for (let i = 0; i < alsaAliases.length; i++) {
|
|
const rule = alsaAliases[i];
|
|
config += " {\n";
|
|
config += ` matches = [ { "node.name" = "${rule.nodeName}" } ]\n`;
|
|
config += ` actions = { update-props = { "node.description" = "${rule.alias}" } }\n`;
|
|
config += " }";
|
|
if (i < alsaAliases.length - 1)
|
|
config += ",";
|
|
config += "\n";
|
|
}
|
|
config += "]\n\n";
|
|
}
|
|
|
|
if (bluezAliases.length > 0) {
|
|
config += "monitor.bluez.rules = [\n";
|
|
for (let i = 0; i < bluezAliases.length; i++) {
|
|
const rule = bluezAliases[i];
|
|
config += " {\n";
|
|
config += ` matches = [ { "node.name" = "${rule.nodeName}" } ]\n`;
|
|
config += ` actions = { update-props = { "node.description" = "${rule.alias}" } }\n`;
|
|
config += " }";
|
|
if (i < bluezAliases.length - 1)
|
|
config += ",";
|
|
config += "\n";
|
|
}
|
|
config += "]\n\n";
|
|
}
|
|
|
|
if (otherAliases.length > 0) {
|
|
config += "# Other device aliases (RAOP, USB, and other devices)\n";
|
|
config += "wireplumber.rules = [\n";
|
|
for (let i = 0; i < otherAliases.length; i++) {
|
|
const rule = otherAliases[i];
|
|
config += " {\n";
|
|
config += ` matches = [\n`;
|
|
config += ` { "node.name" = "${rule.nodeName}" }\n`;
|
|
config += ` ]\n`;
|
|
config += ` actions = {\n`;
|
|
config += ` update-props = {\n`;
|
|
config += ` "node.description" = "${rule.alias}"\n`;
|
|
config += ` "node.nick" = "${rule.alias}"\n`;
|
|
config += ` "device.description" = "${rule.alias}"\n`;
|
|
config += ` }\n`;
|
|
config += ` }\n`;
|
|
config += " }";
|
|
if (i < otherAliases.length - 1)
|
|
config += ",";
|
|
config += "\n";
|
|
}
|
|
config += "]\n";
|
|
}
|
|
|
|
return config;
|
|
}
|
|
|
|
function reloadWireplumberConfig() {
|
|
if (wireplumberReloading) {
|
|
return;
|
|
}
|
|
|
|
wireplumberReloading = true;
|
|
wireplumberReloadStarted();
|
|
|
|
if (!SessionService.systemctlCommandAvailable) {
|
|
Proc.runCommand("restartWireplumber", ["sh", "-c", "pkill -x wireplumber; sleep 1"], () => {
|
|
Quickshell.execDetached(["wireplumber"]);
|
|
wireplumberReloading = false;
|
|
ToastService.showInfo(I18n.tr("Audio system restarted"), I18n.tr("Device names updated"));
|
|
wireplumberReloadCompleted(true);
|
|
}, 5000);
|
|
return;
|
|
}
|
|
|
|
Proc.runCommand("restartWireplumber", ["systemctl", "--user", "restart", "wireplumber"], (output, exitCode) => {
|
|
wireplumberReloading = false;
|
|
|
|
if (exitCode === 0) {
|
|
ToastService.showInfo(I18n.tr("Audio system restarted"), I18n.tr("Device names updated"));
|
|
wireplumberReloadCompleted(true);
|
|
} else {
|
|
log.error("Failed to restart WirePlumber:", output);
|
|
ToastService.showError(I18n.tr("Failed to restart audio system"), output);
|
|
wireplumberReloadCompleted(false);
|
|
}
|
|
}, 5000);
|
|
}
|
|
|
|
function loadDeviceAliases() {
|
|
const configPath = wireplumberConfigPath;
|
|
|
|
Proc.runCommand("readWireplumberConfig", ["cat", configPath], (output, exitCode) => {
|
|
if (exitCode !== 0) {
|
|
log.debug("No existing WirePlumber config found");
|
|
return;
|
|
}
|
|
|
|
const aliases = {};
|
|
const lines = output.split('\n');
|
|
let currentNodeName = null;
|
|
|
|
for (const line of lines) {
|
|
const nodeNameMatch = line.match(/"node\.name"\s*=\s*"([^"]+)"/);
|
|
if (nodeNameMatch) {
|
|
currentNodeName = nodeNameMatch[1];
|
|
}
|
|
|
|
const descriptionMatch = line.match(/"node\.description"\s*=\s*"([^"]+)"/);
|
|
if (descriptionMatch && currentNodeName) {
|
|
aliases[currentNodeName] = descriptionMatch[1];
|
|
currentNodeName = null;
|
|
}
|
|
}
|
|
|
|
if (Object.keys(aliases).length > 0) {
|
|
deviceAliases = aliases;
|
|
log.debug("Loaded", Object.keys(aliases).length, "device aliases");
|
|
}
|
|
}, 0);
|
|
}
|
|
|
|
Connections {
|
|
target: root.sink?.audio ?? null
|
|
|
|
function onVolumeChanged() {
|
|
if (SessionData.suppressOSD)
|
|
return;
|
|
root.playVolumeChangeSoundIfEnabled();
|
|
}
|
|
}
|
|
|
|
Connections {
|
|
target: root.source?.audio ?? null
|
|
|
|
function onMutedChanged() {
|
|
root.micMuteChanged();
|
|
}
|
|
}
|
|
|
|
function checkSoundThemeSupport() {
|
|
Proc.runCommand("checkSoundThemeSupport", ["sh", "-c", GSettings.getCmd("org.gnome.desktop.sound", "theme-name")], (output, exitCode) => {
|
|
soundThemeSupported = (output || "").trim().length > 0;
|
|
if (!soundThemeSupported) {
|
|
markSoundThemeResolved();
|
|
return;
|
|
}
|
|
scanSoundThemes();
|
|
getCurrentSoundTheme();
|
|
}, 0);
|
|
}
|
|
|
|
function scanSoundThemes() {
|
|
const xdgDataDirs = Quickshell.env("XDG_DATA_DIRS");
|
|
const searchPaths = xdgDataDirs && xdgDataDirs.trim() !== "" ? xdgDataDirs.split(":").concat(Paths.strip(StandardPaths.writableLocation(StandardPaths.GenericDataLocation))) : ["/usr/share", "/usr/local/share", Paths.strip(StandardPaths.writableLocation(StandardPaths.GenericDataLocation))];
|
|
|
|
const basePaths = searchPaths.map(p => p + "/sounds").join(" ");
|
|
const script = `
|
|
for base_dir in ${basePaths}; do
|
|
[ -d "$base_dir" ] || continue
|
|
for theme_dir in "$base_dir"/*; do
|
|
[ -d "$theme_dir/stereo" ] || continue
|
|
basename "$theme_dir"
|
|
done
|
|
done | sort -u
|
|
`;
|
|
|
|
Proc.runCommand("scanSoundThemes", ["sh", "-c", script], (output, exitCode) => {
|
|
if (exitCode === 0 && output.trim()) {
|
|
const themes = output.trim().split('\n').filter(t => t && t.length > 0);
|
|
availableSoundThemes = themes;
|
|
} else {
|
|
availableSoundThemes = [];
|
|
}
|
|
}, 0);
|
|
}
|
|
|
|
function getCurrentSoundTheme() {
|
|
Proc.runCommand("getCurrentSoundTheme", ["sh", "-c", GSettings.getCmd("org.gnome.desktop.sound", "theme-name")], (output, exitCode) => {
|
|
currentSoundTheme = output.trim();
|
|
log.debug("Current system sound theme:", currentSoundTheme || "none");
|
|
if (currentSoundTheme && SettingsData.useSystemSoundTheme) {
|
|
discoverSoundFiles(currentSoundTheme);
|
|
return;
|
|
}
|
|
markSoundThemeResolved();
|
|
}, 0);
|
|
}
|
|
|
|
function refreshSoundThemes() {
|
|
if (!soundThemeSupported)
|
|
return;
|
|
scanSoundThemes();
|
|
}
|
|
|
|
function selectSoundTheme(themeName) {
|
|
if (!themeName) {
|
|
SettingsData.set("useSystemSoundTheme", false);
|
|
return;
|
|
}
|
|
if (themeName === currentSoundTheme) {
|
|
SettingsData.set("useSystemSoundTheme", true);
|
|
return;
|
|
}
|
|
Proc.runCommand("setSoundTheme", ["sh", "-c", GSettings.setCmd("org.gnome.desktop.sound", "theme-name", themeName)], (output, exitCode) => {
|
|
if (exitCode !== 0)
|
|
return;
|
|
currentSoundTheme = themeName;
|
|
if (SettingsData.useSystemSoundTheme) {
|
|
discoverSoundFiles(themeName);
|
|
return;
|
|
}
|
|
SettingsData.set("useSystemSoundTheme", true);
|
|
}, 0);
|
|
}
|
|
|
|
function discoverSoundFiles(themeName) {
|
|
if (!themeName) {
|
|
soundFilePaths = {};
|
|
markSoundThemeResolved();
|
|
return;
|
|
}
|
|
|
|
const xdgDataDirs = Quickshell.env("XDG_DATA_DIRS");
|
|
const searchPaths = xdgDataDirs && xdgDataDirs.trim() !== "" ? xdgDataDirs.split(":").concat(Paths.strip(StandardPaths.writableLocation(StandardPaths.GenericDataLocation))) : ["/usr/share", "/usr/local/share", Paths.strip(StandardPaths.writableLocation(StandardPaths.GenericDataLocation))];
|
|
|
|
const extensions = ["oga", "ogg", "wav", "mp3", "flac"];
|
|
const themesToSearch = themeName !== "freedesktop" ? `${themeName} freedesktop` : themeName;
|
|
|
|
const script = `
|
|
for event_key in audio-volume-change power-plug power-unplug message message-new-instant desktop-login; do
|
|
found=0
|
|
|
|
case "$event_key" in
|
|
message)
|
|
names="dialog-information message message-lowpriority bell"
|
|
;;
|
|
message-new-instant)
|
|
names="dialog-warning message-new-instant message-highlight"
|
|
;;
|
|
*)
|
|
names="$event_key"
|
|
;;
|
|
esac
|
|
|
|
for theme in ${themesToSearch}; do
|
|
for event_name in $names; do
|
|
for base_path in ${searchPaths.join(" ")}; do
|
|
theme_dir="$base_path/sounds/$theme"
|
|
[ -d "$theme_dir" ] || continue
|
|
file_path=$(find -L "$theme_dir" \\( ${extensions.map(e => `-name "$event_name.${e}"`).join(" -o ")} \\) -print 2>/dev/null | sort | head -1)
|
|
if [ -n "$file_path" ]; then
|
|
echo "$event_key=$file_path"
|
|
found=1
|
|
break
|
|
fi
|
|
done
|
|
[ $found -eq 1 ] && break
|
|
done
|
|
[ $found -eq 1 ] && break
|
|
done
|
|
done
|
|
exit 0
|
|
`;
|
|
|
|
Proc.runCommand("discoverSoundFiles", ["sh", "-c", script], (output, exitCode) => {
|
|
const paths = {};
|
|
if (exitCode === 0 && output.trim()) {
|
|
const lines = output.trim().split('\n');
|
|
for (let line of lines) {
|
|
const parts = line.split('=');
|
|
if (parts.length === 2) {
|
|
paths[parts[0]] = "file://" + parts[1];
|
|
}
|
|
}
|
|
}
|
|
soundFilePaths = paths;
|
|
markSoundThemeResolved();
|
|
}, 0);
|
|
}
|
|
|
|
function markSoundThemeResolved() {
|
|
soundThemeResolved = true;
|
|
if (!loginSoundPending)
|
|
return;
|
|
loginSoundPending = false;
|
|
playLoginSound();
|
|
}
|
|
|
|
function getSoundPath(soundEvent) {
|
|
const soundMap = {
|
|
"audio-volume-change": "../assets/sounds/freedesktop/audio-volume-change.wav",
|
|
"power-plug": "../assets/sounds/plasma/power-plug.wav",
|
|
"power-unplug": "../assets/sounds/plasma/power-unplug.wav",
|
|
"message": "../assets/sounds/freedesktop/message.wav",
|
|
"message-new-instant": "../assets/sounds/freedesktop/message-new-instant.wav",
|
|
"desktop-login": "../assets/sounds/freedesktop/desktop-login.wav"
|
|
};
|
|
|
|
const specialConditions = {
|
|
"smooth": ["audio-volume-change"]
|
|
};
|
|
|
|
const themeLower = currentSoundTheme.toLowerCase();
|
|
if (SettingsData.useSystemSoundTheme && specialConditions[themeLower]?.includes(soundEvent)) {
|
|
const bundledPath = Qt.resolvedUrl(soundMap[soundEvent] || "../assets/sounds/freedesktop/message.wav");
|
|
log.debug("Using bundled sound (special condition) for", soundEvent, ":", bundledPath);
|
|
return bundledPath;
|
|
}
|
|
|
|
if (SettingsData.useSystemSoundTheme && soundFilePaths[soundEvent]) {
|
|
log.debug("Using system sound for", soundEvent, ":", soundFilePaths[soundEvent]);
|
|
return soundFilePaths[soundEvent];
|
|
}
|
|
|
|
const bundledPath = Qt.resolvedUrl(soundMap[soundEvent] || "../assets/sounds/freedesktop/message.wav");
|
|
log.debug("Using bundled sound for", soundEvent, ":", bundledPath);
|
|
return bundledPath;
|
|
}
|
|
|
|
function reloadSounds() {
|
|
log.debug("Reloading sounds, useSystemSoundTheme:", SettingsData.useSystemSoundTheme, "currentSoundTheme:", currentSoundTheme);
|
|
if (SettingsData.useSystemSoundTheme && currentSoundTheme) {
|
|
discoverSoundFiles(currentSoundTheme);
|
|
return;
|
|
}
|
|
soundFilePaths = {};
|
|
markSoundThemeResolved();
|
|
}
|
|
|
|
function isMediaPlaying() {
|
|
return MprisController.activePlayer?.isPlaying ?? false;
|
|
}
|
|
|
|
function shouldMuteForMedia() {
|
|
return SettingsData.muteSoundsWhenMediaPlaying && isMediaPlaying();
|
|
}
|
|
|
|
function ensurePlayers() {
|
|
if (!SettingsData.soundsEnabled)
|
|
return;
|
|
MultimediaService.ensureProbed();
|
|
playersRequested = true;
|
|
}
|
|
|
|
function playVolumeChangeSound() {
|
|
ensurePlayers();
|
|
if (!soundsAvailable || !volumeChangeSound || notificationsAudioMuted || shouldMuteForMedia())
|
|
return;
|
|
volumeChangeSound.play();
|
|
}
|
|
|
|
function playPowerPlugSound() {
|
|
ensurePlayers();
|
|
if (!soundsAvailable || !powerPlugSound || notificationsAudioMuted || shouldMuteForMedia())
|
|
return;
|
|
powerPlugSound.play();
|
|
}
|
|
|
|
function playPowerUnplugSound() {
|
|
ensurePlayers();
|
|
if (!soundsAvailable || !powerUnplugSound || notificationsAudioMuted || shouldMuteForMedia())
|
|
return;
|
|
powerUnplugSound.play();
|
|
}
|
|
|
|
function playNormalNotificationSound() {
|
|
ensurePlayers();
|
|
if (!soundsAvailable || !normalNotificationSound || notificationsAudioMuted || shouldMuteForMedia())
|
|
return;
|
|
normalNotificationSound.play();
|
|
}
|
|
|
|
function playCriticalNotificationSound() {
|
|
ensurePlayers();
|
|
if (!soundsAvailable || !criticalNotificationSound || notificationsAudioMuted || shouldMuteForMedia())
|
|
return;
|
|
criticalNotificationSound.play();
|
|
}
|
|
|
|
function playLoginSound() {
|
|
ensurePlayers();
|
|
// playing before the theme paths land swaps the player source mid-playback, which stops it
|
|
if (SettingsData.useSystemSoundTheme && !soundThemeResolved) {
|
|
loginSoundPending = true;
|
|
return;
|
|
}
|
|
if (!soundsAvailable || !loginSound || notificationsAudioMuted || shouldMuteForMedia()) {
|
|
return;
|
|
}
|
|
loginSound.play();
|
|
}
|
|
|
|
function playLoginSoundIfApplicable() {
|
|
if (SettingsData.soundsEnabled && SettingsData.soundLogin && !notificationsAudioMuted) {
|
|
// plays login sound on session start, but only if a specific file doesn't exist,
|
|
// to prevent it from playing on every DMS restart during the session
|
|
const runtimeDir = Quickshell.env("XDG_RUNTIME_DIR");
|
|
const sessionId = Quickshell.env("XDG_SESSION_ID") || "0";
|
|
|
|
if (!runtimeDir)
|
|
return;
|
|
|
|
const loginFile = `${runtimeDir}/danklinux.login-${sessionId}`;
|
|
|
|
// if file doesn't exist, touch it (0)
|
|
// If it exists, do nothing (1)
|
|
loginSoundChecker.command = ["sh", "-c", `[ ! -f ${loginFile} ] && touch ${loginFile}`];
|
|
loginSoundChecker.running = true;
|
|
}
|
|
}
|
|
|
|
function playVolumeChangeSoundIfEnabled() {
|
|
if (SettingsData.soundsEnabled && SettingsData.soundVolumeChanged && !notificationsAudioMuted) {
|
|
playVolumeChangeSound();
|
|
}
|
|
}
|
|
|
|
readonly property string sinkVolumeIconName: volumeIconName(sink)
|
|
readonly property bool sinkSilent: isSilent(sink)
|
|
|
|
function isSilent(node) {
|
|
const audio = node?.audio;
|
|
if (!audio)
|
|
return false;
|
|
return audio.muted || audio.volume === 0;
|
|
}
|
|
|
|
function volumeIcon(volume, muted) {
|
|
if (muted)
|
|
return "volume_off";
|
|
if (volume === 0)
|
|
return "volume_mute";
|
|
return volume <= 0.33 ? "volume_down" : "volume_up";
|
|
}
|
|
|
|
function volumeIconName(node, noDeviceIcon = "volume_off") {
|
|
const audio = node?.audio;
|
|
if (!audio)
|
|
return noDeviceIcon;
|
|
return volumeIcon(audio.volume, audio.muted);
|
|
}
|
|
|
|
function sinkIcon(node) {
|
|
if (!node)
|
|
return "speaker";
|
|
|
|
const props = node.properties || {};
|
|
const formFactor = (props["device.form-factor"] || "").toLowerCase();
|
|
|
|
switch (formFactor) {
|
|
case "headphone":
|
|
case "headset":
|
|
case "hands-free":
|
|
case "handset":
|
|
return "headset";
|
|
case "tv":
|
|
case "monitor":
|
|
return "tv";
|
|
case "speaker":
|
|
case "computer":
|
|
case "hifi":
|
|
case "portable":
|
|
case "car":
|
|
return "speaker";
|
|
}
|
|
|
|
const bus = (props["device.bus"] || "").toLowerCase();
|
|
if (bus === "bluetooth")
|
|
return "headset";
|
|
|
|
const name = (node.name || "").toLowerCase();
|
|
if (name.includes("hdmi"))
|
|
return "tv";
|
|
if (name.includes("iec958") || name.includes("spdif"))
|
|
return "speaker";
|
|
|
|
if (bus === "usb")
|
|
return "headset";
|
|
|
|
return "speaker";
|
|
}
|
|
|
|
function displayName(node) {
|
|
if (!node) {
|
|
return "";
|
|
}
|
|
|
|
if (node.name && deviceAliases[node.name]) {
|
|
return deviceAliases[node.name];
|
|
}
|
|
|
|
if (node.properties && node.properties["node.description"]) {
|
|
const desc = node.properties["node.description"];
|
|
if (desc !== node.name) {
|
|
return desc;
|
|
}
|
|
}
|
|
|
|
if (node.description && node.description !== node.name) {
|
|
return node.description;
|
|
}
|
|
|
|
if (node.properties && node.properties["device.description"]) {
|
|
return node.properties["device.description"];
|
|
}
|
|
|
|
if (node.nickname && node.nickname !== node.name) {
|
|
return node.nickname;
|
|
}
|
|
|
|
if (node.name.includes("analog-stereo")) {
|
|
return "Built-in Audio Analog Stereo";
|
|
}
|
|
if (node.name.includes("bluez")) {
|
|
return "Bluetooth Audio";
|
|
}
|
|
if (node.name.includes("usb")) {
|
|
return "USB Audio";
|
|
}
|
|
if (node.name.includes("hdmi")) {
|
|
return "HDMI Audio";
|
|
}
|
|
|
|
return node.name;
|
|
}
|
|
|
|
function originalName(node) {
|
|
if (!node) {
|
|
return "";
|
|
}
|
|
|
|
if (node.name.includes("analog-stereo")) {
|
|
return "Built-in Audio Analog Stereo";
|
|
}
|
|
if (node.name.includes("bluez")) {
|
|
return "Bluetooth Audio";
|
|
}
|
|
if (node.name.includes("usb")) {
|
|
return "USB Audio";
|
|
}
|
|
if (node.name.includes("hdmi")) {
|
|
return "HDMI Audio";
|
|
}
|
|
if (node.name.includes("raop_sink")) {
|
|
const match = node.name.match(/raop_sink\.([^.]+)/);
|
|
if (match) {
|
|
return match[1].replace(/-/g, " ");
|
|
}
|
|
}
|
|
|
|
if (node.properties && node.properties["device.description"]) {
|
|
return node.properties["device.description"];
|
|
}
|
|
|
|
if (node.nickname && node.nickname !== node.name) {
|
|
return node.nickname;
|
|
}
|
|
|
|
return node.name;
|
|
}
|
|
|
|
function subtitle(name) {
|
|
if (!name) {
|
|
return "";
|
|
}
|
|
|
|
if (name.includes('usb-')) {
|
|
if (name.includes('SteelSeries')) {
|
|
return "USB Gaming Headset";
|
|
}
|
|
if (name.includes('Generic')) {
|
|
return "USB Audio Device";
|
|
}
|
|
return "USB Audio";
|
|
}
|
|
|
|
if (name.includes('pci-')) {
|
|
if (name.includes('01_00.1') || name.includes('01:00.1')) {
|
|
return "NVIDIA GPU Audio";
|
|
}
|
|
return "PCI Audio";
|
|
}
|
|
|
|
if (name.includes('bluez')) {
|
|
return "Bluetooth Audio";
|
|
}
|
|
if (name.includes('analog')) {
|
|
return "Built-in Audio";
|
|
}
|
|
if (name.includes('hdmi')) {
|
|
return "HDMI Audio";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
PwObjectTracker {
|
|
objects: Pipewire.nodes.values.filter(node => node.audio && (SettingsData.audioShowStreamDevices || !node.isStream))
|
|
}
|
|
|
|
function setVolume(percentage) {
|
|
if (!root.sink?.audio)
|
|
return "No audio sink available";
|
|
if (isNaN(percentage))
|
|
return "Invalid percentage";
|
|
|
|
const maxVol = root.sinkMaxVolume;
|
|
const clampedVolume = Math.max(0, Math.min(maxVol, percentage));
|
|
root.sink.audio.volume = clampedVolume / 100;
|
|
return `Volume set to ${clampedVolume}%`;
|
|
}
|
|
|
|
function outputVolumeStep(step) {
|
|
const parsed = parseInt(step || "5");
|
|
return isNaN(parsed) ? 5 : Math.max(0, parsed);
|
|
}
|
|
|
|
function adjustDefaultSinkVolume(step, direction) {
|
|
const audio = root.sink.audio;
|
|
const maxVol = root.sinkMaxVolume;
|
|
const stepValue = outputVolumeStep(step);
|
|
const currentVolume = Math.round(audio.volume * 100);
|
|
const newVolume = Math.max(0, Math.min(maxVol, currentVolume + direction * stepValue));
|
|
|
|
if (audio.muted)
|
|
audio.muted = false;
|
|
|
|
audio.volume = newVolume / 100;
|
|
return newVolume;
|
|
}
|
|
|
|
function toggleMute() {
|
|
if (!root.sink?.audio) {
|
|
return "No audio sink available";
|
|
}
|
|
|
|
root.sink.audio.muted = !root.sink.audio.muted;
|
|
return root.sink.audio.muted ? "Audio muted" : "Audio unmuted";
|
|
}
|
|
|
|
function setMicVolume(percentage) {
|
|
if (!root.source?.audio) {
|
|
return "No audio source available";
|
|
}
|
|
|
|
const clampedVolume = Math.max(0, Math.min(100, percentage));
|
|
root.source.audio.volume = clampedVolume / 100;
|
|
micVolumeChanged();
|
|
return `Microphone volume set to ${clampedVolume}%`;
|
|
}
|
|
|
|
function toggleMicMute() {
|
|
if (!root.source?.audio) {
|
|
return "No audio source available";
|
|
}
|
|
|
|
root.source.audio.muted = !root.source.audio.muted;
|
|
return root.source.audio.muted ? "Microphone muted" : "Microphone unmuted";
|
|
}
|
|
|
|
function incrementMicVolume(step) {
|
|
if (!root.source?.audio)
|
|
return "No audio source available";
|
|
|
|
if (root.source.audio.muted)
|
|
root.source.audio.muted = false;
|
|
|
|
const currentVolume = Math.round(root.source.audio.volume * 100);
|
|
const stepValue = parseInt(step || "5");
|
|
const newVolume = Math.max(0, Math.min(100, currentVolume + stepValue));
|
|
|
|
root.source.audio.volume = newVolume / 100;
|
|
micVolumeChanged();
|
|
return `Microphone volume increased to ${newVolume}%`;
|
|
}
|
|
|
|
function decrementMicVolume(step) {
|
|
if (!root.source?.audio)
|
|
return "No audio source available";
|
|
|
|
if (root.source.audio.muted)
|
|
root.source.audio.muted = false;
|
|
|
|
const currentVolume = Math.round(root.source.audio.volume * 100);
|
|
const stepValue = parseInt(step || "5");
|
|
const newVolume = Math.max(0, Math.min(100, currentVolume - stepValue));
|
|
|
|
root.source.audio.volume = newVolume / 100;
|
|
micVolumeChanged();
|
|
return `Microphone volume decreased to ${newVolume}%`;
|
|
}
|
|
|
|
IpcHandler {
|
|
target: "audio"
|
|
|
|
function setvolume(percentage: string): string {
|
|
return root.setVolume(parseInt(percentage));
|
|
}
|
|
|
|
function increment(step: string): string {
|
|
if (!root.sink?.audio)
|
|
return "No audio sink available";
|
|
|
|
const newVolume = root.adjustDefaultSinkVolume(step, 1);
|
|
return `Volume increased to ${newVolume}%`;
|
|
}
|
|
|
|
function decrement(step: string): string {
|
|
if (!root.sink?.audio)
|
|
return "No audio sink available";
|
|
|
|
const newVolume = root.adjustDefaultSinkVolume(step, -1);
|
|
return `Volume decreased to ${newVolume}%`;
|
|
}
|
|
|
|
function mute(): string {
|
|
return root.toggleMute();
|
|
}
|
|
|
|
function setmic(percentage: string): string {
|
|
return root.setMicVolume(parseInt(percentage));
|
|
}
|
|
|
|
function micmute(): string {
|
|
return root.toggleMicMute();
|
|
}
|
|
|
|
function status(): string {
|
|
let result = "Audio Status:\n";
|
|
|
|
if (root.sink?.audio) {
|
|
const volume = Math.round(root.sink.audio.volume * 100);
|
|
const muteStatus = root.sink.audio.muted ? " (muted)" : "";
|
|
const maxVol = root.sinkMaxVolume;
|
|
result += `Output: ${volume}%${muteStatus} (max: ${maxVol}%)\n`;
|
|
} else {
|
|
result += "Output: No sink available\n";
|
|
}
|
|
|
|
if (root.source?.audio) {
|
|
const micVolume = Math.round(root.source.audio.volume * 100);
|
|
const muteStatus = root.source.audio.muted ? " (muted)" : "";
|
|
result += `Input: ${micVolume}%${muteStatus}`;
|
|
} else {
|
|
result += "Input: No source available";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function getmaxvolume(): string {
|
|
return `${root.sinkMaxVolume}`;
|
|
}
|
|
|
|
function setmaxvolume(percent: string): string {
|
|
if (!root.sink?.name)
|
|
return "No audio sink available";
|
|
const val = parseInt(percent);
|
|
if (isNaN(val))
|
|
return "Invalid percentage";
|
|
SessionData.setDeviceMaxVolume(root.sink.name, val);
|
|
return `Max volume set to ${SessionData.getDeviceMaxVolume(root.sink.name)}%`;
|
|
}
|
|
|
|
function getmaxvolumefor(nodeName: string): string {
|
|
if (!nodeName)
|
|
return "No node name specified";
|
|
return `${SessionData.getDeviceMaxVolume(nodeName)}`;
|
|
}
|
|
|
|
function setmaxvolumefor(nodeName: string, percent: string): string {
|
|
if (!nodeName)
|
|
return "No node name specified";
|
|
const val = parseInt(percent);
|
|
if (isNaN(val))
|
|
return "Invalid percentage";
|
|
SessionData.setDeviceMaxVolume(nodeName, val);
|
|
return `Max volume for ${nodeName} set to ${SessionData.getDeviceMaxVolume(nodeName)}%`;
|
|
}
|
|
|
|
function cycleoutput(): string {
|
|
const result = root.cycleAudioOutput();
|
|
if (!result)
|
|
return "Only one audio output available";
|
|
return `Switched to: ${result}`;
|
|
}
|
|
}
|
|
Connections {
|
|
target: SettingsData
|
|
function onUseSystemSoundThemeChanged() {
|
|
reloadSounds();
|
|
}
|
|
}
|
|
|
|
onSoundsAvailableChanged: {
|
|
if (!soundsAvailable)
|
|
return;
|
|
checkSoundThemeSupport();
|
|
}
|
|
|
|
Component.onCompleted: {
|
|
rebuildTypedNodeLists();
|
|
loadDeviceAliases();
|
|
if (SettingsData.soundsEnabled && SettingsData.useSystemSoundTheme)
|
|
getCurrentSoundTheme();
|
|
}
|
|
}
|