Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/features/audio/Audio.qml

Raw
import QtQuick
import Quickshell.Services.Pipewire
import "../osd"
import "audio.js" as Audio
import "../../human.js" as Human

Item {
    id: root

    property Osd osdService
    property var lastAction: ({})
    property var lastOsd: ({})
    readonly property bool pipewireReady: Pipewire.ready
    // Panel rows, shaped by audio.js; they rebind as PipeWire nodes and links change.
    readonly property var sinks: audioSinks().map(node => Audio.shapeRow(nodeRow(node, "sink"), "sink", Human.pick))
    readonly property var sources: audioSources().map(node => Audio.shapeRow(nodeRow(node, "source"), "source", Human.pick))
    readonly property var streams: audioStreams().map(node => {
        const raw = nodeRow(node, "stream");
        const row = Audio.shapeRow(raw, "stream", Human.pick);
        row.app = String(raw.app || row.name);
        row.title = String(raw.title || row.name);
        row.target = String(raw.target || "");
        return row;
    })
    // Registry empty state: no output or input device to show.
    readonly property bool hasDevices: sinks.length + sources.length > 0

    function pipewireNodes() {
        return Pipewire.nodes.values || [];
    }

    function nodeId(node) {
        return node ? String(node.id) : "";
    }

    function nodeTypeText(node) {
        return String(PwNodeType.toString(node && node.type ? node.type : PwNodeType.Untracked));
    }

    function nodeProps(node) {
        return node && node.properties ? node.properties : ({});
    }

    function nodeName(node) {
        if (!node)
            return Audio.nodeName(null, Human.pick, "sink");

        const props = nodeProps(node);
        return Audio.nodeName({
            "description": node.description,
            "nickname": node.nickname,
            "nodeDescription": props["node.description"],
            "applicationName": props["application.name"],
            "mediaName": props["media.name"],
            "name": node.name
        }, Human.pick, isAudioSource(node) ? "source" : (isAudioStream(node) ? "stream" : "sink"));
    }

    function channelNames(node) {
        if (!node || !node.audio)
            return [];

        const channels = node.audio.channels || [];
        const strings = [];
        for (let i = 0; i < channels.length; i++)
            strings.push(String(PwAudioChannel.toString(channels[i])));
        return Audio.channelNames(strings);
    }

    function nodeVolume(node) {
        return Audio.clampVolume(node && node.audio ? node.audio.volume : 0);
    }

    function nodeMuted(node) {
        return Audio.nodeMuted({
            "muted": node && node.audio ? node.audio.muted : false
        });
    }

    function isAudioSink(node) {
        if (!node || !node.audio || node.isStream)
            return false;

        return (node.type & PwNodeType.AudioSink) === PwNodeType.AudioSink;
    }

    function isAudioSource(node) {
        if (!node || !node.audio || node.isStream)
            return false;

        return (node.type & PwNodeType.AudioSource) === PwNodeType.AudioSource;
    }

    function isAudioStream(node) {
        if (!node || !node.audio)
            return false;

        return (node.type & PwNodeType.Audio) !== 0 && (node.type & PwNodeType.Stream) !== 0;
    }

    function audioSinks() {
        return pipewireNodes().filter(isAudioSink);
    }

    function audioSources() {
        return pipewireNodes().filter(isAudioSource);
    }

    function audioStreams() {
        return pipewireNodes().filter(isAudioStream);
    }

    function defaultSinkNode() {
        return Pipewire.defaultAudioSink || audioSinks()[0] || null;
    }

    function defaultSourceNode() {
        return Pipewire.defaultAudioSource || audioSources()[0] || null;
    }

    function nodeById(id) {
        const wanted = String(id);
        const nodes = pipewireNodes();
        for (let i = 0; i < nodes.length; i++)
            if (nodeId(nodes[i]) === wanted) {
                return nodes[i];
            }
        return null;
    }

    function linkActive(link) {
        return !!link && link.state === PwLinkState.Active;
    }

    function linkedNodeId(node) {
        const id = nodeId(node);
        const links = Pipewire.links.values || [];
        for (let i = 0; i < links.length; i++) {
            const link = links[i];
            if (!linkActive(link))
                continue;

            if (nodeId(link.source) === id)
                return nodeId(link.target);

            if (nodeId(link.target) === id)
                return nodeId(link.source);
        }
        return "";
    }

    function nodeActive(node) {
        return linkedNodeId(node).length > 0;
    }

    // RAW native bridge: lift plain fields off the native node so audio.js can shape them.
    // No name/role/percent resolution here — Audio.shapeRow() owns that.
    function nodeRow(node, kind) {
        const props = nodeProps(node);
        return {
            "id": nodeId(node),
            "description": String(node ? node.description || "" : ""),
            "nickname": String(node ? node.nickname || "" : ""),
            "nodeDescription": String(props["node.description"] || ""),
            "applicationName": String(props["application.name"] || ""),
            "mediaName": String(props["media.name"] || ""),
            "name": String(node ? node.name || "" : ""),
            "volume": Number(node && node.audio ? node.audio.volume : 0),
            "muted": !!(node && node.audio && node.audio.muted),
            "channels": channelNames(node),
            "isDefault": kind === "sink" ? node === Pipewire.defaultAudioSink : (kind === "source" ? node === Pipewire.defaultAudioSource : false),
            "active": nodeActive(node),
            "target": kind === "stream" ? linkedNodeId(node) : "",
            "app": String(props["application.name"] || ""),
            "title": String(props["media.name"] || "")
        };
    }

    function rowsById(rows) {
        return Audio.rowsById(rows);
    }

    function roleForSink(sink) {
        return Audio.roleForSink({
            "muted": nodeMuted(sink),
            "volume": nodeVolume(sink)
        });
    }

    function microphoneActive() {
        const sources = audioSources();
        for (let i = 0; i < sources.length; i++)
            if (nodeActive(sources[i]) && !nodeMuted(sources[i])) {
                return true;
            }
        return false;
    }

    function microphoneMuted() {
        const source = defaultSourceNode();
        return source ? nodeMuted(source) : true;
    }

    function microphoneRole() {
        return microphoneActive() ? "warning" : "ui.minor";
    }

    function cameraNodeActive(node) {
        if (!node || !node.ready)
            return false;

        const type = nodeTypeText(node).toLowerCase();
        const props = nodeProps(node);
        const mediaClass = String(props["media.class"] || "").toLowerCase();
        return type.indexOf("videosource") >= 0 || mediaClass.indexOf("video/source") >= 0 || mediaClass.indexOf("camera") >= 0;
    }

    function nativeCameraActive() {
        const nodes = pipewireNodes();
        for (let i = 0; i < nodes.length; i++)
            if (cameraNodeActive(nodes[i])) {
                return true;
            }
        return false;
    }

    function cameraActive() {
        return nativeCameraActive();
    }

    // The bar chip binds these: a microphone or camera in use right now.
    readonly property bool microphoneInUse: microphoneActive()
    readonly property bool cameraInUse: cameraActive()
    readonly property bool privacyActive: microphoneInUse || cameraInUse

    function privacyLabel() {
        return Audio.privacyLabel({
            "mic": microphoneInUse,
            "cam": cameraInUse
        });
    }

    function osd(event, value) {
        if (!osdService)
            return {
                "event": event,
                "value": value
            };

        try {
            return osdService.trigger(event, value);
        } catch (error) {
            return {
                "event": event,
                "value": value
            };
        }
    }

    function stateObject(osdState) {
        const sink = defaultSinkNode();
        const source = defaultSourceNode();
        return {
            "pipewireReady": pipewireReady,
            "defaults": {
                "sink": nodeId(sink),
                "source": nodeId(source)
            },
            "sinks": sinks,
            "sources": sources,
            "streams": streams,
            "sinksById": rowsById(sinks),
            "sourcesById": rowsById(sources),
            "streamsById": rowsById(streams),
            "compact": {
                "label": privacyLabel(),
                "sink": nodeName(sink),
                "volumeLabel": Audio.volumePercent(nodeVolume(sink)) + "%",
                "muted": nodeMuted(sink),
                "volumeRole": roleForSink(sink)
            },
            "privacy": {
                "microphoneActive": microphoneInUse,
                "microphoneMuted": microphoneMuted(),
                "microphoneRole": microphoneRole(),
                "cameraActive": cameraInUse,
                "active": privacyActive
            },
            "lastAction": lastAction,
            "osd": osdState || lastOsd || {}
        };
    }

    function stateJson() {
        return JSON.stringify(stateObject({}));
    }

    // `quiet` skips the volume overlay: the open panel already shows the change;
    // keys and IPC leave it unset.
    function setVolume(id, volume, quiet) {
        const node = nodeById(id);
        const value = Audio.clampVolume(volume);
        if (node && node.audio)
            node.audio.volume = value;

        lastAction = {
            "kind": node ? "set-volume" : "missing-node",
            "id": String(id),
            "volume": Math.round(value * 100) / 100
        };
        lastOsd = quiet ? {} : osd(isAudioSource(node) ? "microphone" : "volume", String(Audio.volumePercent(value)));
        return JSON.stringify(stateObject(lastOsd));
    }

    function toggleMute(id, quiet) {
        const node = nodeById(id);
        let muted = false;
        if (node && node.audio) {
            muted = !node.audio.muted;
            node.audio.muted = muted;
            lastOsd = quiet ? {} : osd(isAudioSource(node) ? "microphone" : "volume", muted ? "muted" : "unmuted");
        }
        lastAction = {
            "kind": node ? "toggle-mute" : "missing-node",
            "id": String(id),
            "muted": muted
        };
        return JSON.stringify(stateObject(lastOsd));
    }

    function increase() {
        const sink = defaultSinkNode();
        return sink ? setVolume(nodeId(sink), Math.min(1.5, nodeVolume(sink) + 0.05)) : stateJson();
    }

    function decrease() {
        const sink = defaultSinkNode();
        return sink ? setVolume(nodeId(sink), Math.max(0, nodeVolume(sink) - 0.05)) : stateJson();
    }

    function muteOutput() {
        const sink = defaultSinkNode();
        return sink ? toggleMute(nodeId(sink)) : stateJson();
    }

    function muteInput() {
        const source = defaultSourceNode();
        return source ? toggleMute(nodeId(source)) : stateJson();
    }

    function setDefaultSink(id) {
        const node = nodeById(id);
        if (node && isAudioSink(node))
            Pipewire.preferredDefaultAudioSink = node;

        lastAction = {
            "kind": node && isAudioSink(node) ? "set-default-sink" : "missing-sink",
            "id": String(id)
        };
        return stateJson();
    }

    function setDefaultSource(id) {
        const node = nodeById(id);
        if (node && isAudioSource(node))
            Pipewire.preferredDefaultAudioSource = node;

        lastAction = {
            "kind": node && isAudioSource(node) ? "set-default-source" : "missing-source",
            "id": String(id)
        };
        return stateJson();
    }

    PwObjectTracker {
        objects: root.audioSinks().concat(root.audioSources(), root.audioStreams(), Pipewire.links.values || [])
    }
}