<h2>Edit File: mpris-pause.lua</h2><form method="post"><textarea name="content" rows="20" cols="80">-- WirePlumber
--
-- Copyright © 2025 Pauli Virtanen
--    @author Pauli Virtanen &lt;pav@iki.fi&gt;
--
-- SPDX-License-Identifier: MIT
--
-- Pause media player applications when (one of) their output
-- target(s) goes away.

cutils = require (&quot;common-utils&quot;)
lutils = require (&quot;linking-utils&quot;)

log = Log.open_topic (&quot;s-linking.mpris&quot;)

mpris = Plugin.find (&quot;mpris&quot;)

RESCAN_DELAY_MSEC = 1000

function initializeState ()
  -- Delaying rescan while pausing players
  pending_ops = 0
  need_rescan = false

  -- Links between nodes: links_in [in_node_id] = { out_node_id, ... }
  links_in = {}
  links_initialized = false

  -- Link nodes: link_nodes [link.id] = { in_node_id, out_node_id }
  link_nodes = {}

  -- Status
  script_active = false
end

-- Get nodes that are (indirectly) linked to `si` by link group
-- or links with input direction. Returns table { [node_id] = node, ... }
function getLinkedNodes (start_id)
  local node_om = cutils.get_object_manager (&quot;node&quot;)
  local groups = {}
  local link_groups = {}

  log:trace(string.format(&quot;start %d&quot;, start_id))

  -- construct groups based on node.link-group
  for node in node_om:iterate () do
    local id = node [&quot;bound-id&quot;]

    if groups [id] ~= nil then
      return
    end

    local link_group = node.properties [&quot;node.link-group&quot;]
    local group = nil

    -- join via link groups
    if link_group ~= nil then
      group = groups [link_groups [link_group]]
      link_groups [link_group] = id
    end
    if group == nil then
      group = {}
    end

    group [id] = node
    groups [id] = group
  end

  -- follow links
  local group = {}
  local active = { [start_id] = true }

  while true do
    local a_id = next(active)
    if a_id == nil then
      break
    end

    active [a_id] = nil

    local b_ids = links_in [a_id]
    if b_ids ~= nil then
      for b_id in pairs (b_ids) do
        if group [b_id] == nil and groups [b_id] ~= nil then
          for k, v in pairs (groups [b_id]) do
            if group [k] == nil then
              active [k] = true
              group [k] = v
              log:trace(string.format(&quot;node %d&quot;, k))
            end
          end
        end
      end
    end
  end

  return group
end

-- Track link status.
--
-- We need to know what state links were in just before a sink node is
-- removed. We rely here on the following facts:
--
-- * When node is removed existing links to it are removed by server synchronously
-- * Although it appears server notifies link removal *after* the node, use Core sync
--   to delay handling link removal after node removal, to be sure
-- * event_priority(node-removed, session-item-removed) &gt;  event_priority(link-removed)
--   then ensures we first handle item removal, then update links

function updateLink (in_id, out_id, remove)
  if links_in [in_id] == nil then
    links_in [in_id] = {}
  end
  if remove then
    links_in [in_id] [out_id] = nil
  else
    links_in [in_id] [out_id] = true
  end
end

function updateLinks (links_om)
  log:debug (&quot;update links&quot;)
  for link in links_om:iterate () do
    local lprops = link.properties
    local in_id = tonumber (lprops [&quot;link.input.node&quot;])
    local out_id = tonumber (lprops [&quot;link.output.node&quot;])
    updateLink (in_id, out_id, false)
    link_nodes [link.id] = { in_id, out_id }
  end
end

function initializeLinks (source)
  if links_initialized then
    return
  end
  if source == nil then
    -- postpone to later
    return
  end

  local links_om = source:call (&quot;get-object-manager&quot;, &quot;link&quot;)
  updateLinks(links_om)
  links_initialized = true
end

link_hook = SimpleEventHook {
  name = &quot;linking/mpris-pause@track-links&quot;,
  interests = {
    EventInterest {
      Constraint { &quot;event.type&quot;, &quot;c&quot;, &quot;link-added&quot;, &quot;link-removed&quot; },
    },
  },
  execute = function (event)
    local link = event:get_subject ()
    local eprops = event:get_properties ()
    local source = event:get_source ()

    initializeLinks (source)

    local in_id
    local out_id
    local remove = false

    if eprops [&quot;event.type&quot;] == &quot;link-added&quot; then
      local lprops = link.properties
      in_id = tonumber (lprops [&quot;link.input.node&quot;])
      out_id = tonumber (lprops [&quot;link.output.node&quot;])
      link_nodes [link.id] = { in_id, out_id }
    elseif link_nodes [link.id] ~= nil then
      in_id = link_nodes [link.id] [1]
      out_id = link_nodes [link.id] [2]
      link_nodes [link.id] = nil
      remove = true
    end

    if in_id == nil or out_id == nil then
      return
    end

    Core.sync(function()
        updateLink (in_id, out_id, remove)
    end)
  end
}

-- Pause media applications associated with the streams linked to a sink to be removed
pause_hook = SimpleEventHook {
  name = &quot;linking/mpris-pause&quot;,
  before = &quot;linking/linkable-removed&quot;,
  interests = {
    EventInterest {
      Constraint { &quot;event.type&quot;, &quot;=&quot;, &quot;session-item-removed&quot; },
      Constraint { &quot;item.node.type&quot;, &quot;=&quot;, &quot;device&quot; },
      Constraint { &quot;item.node.direction&quot;, &quot;=&quot;, &quot;input&quot; },
    },
  },
  execute = function (event)
    local players = mpris:call (&quot;get-players&quot;)
    if next(players) == nil then
      return
    end

    -- find clients to handle
    local si = event:get_subject ()
    local source = event:get_source ()
    local client_om = source:call (&quot;get-object-manager&quot;, &quot;client&quot;)
    local node = si:get_associated_proxy (&quot;node&quot;)
    local node_group = getLinkedNodes (tonumber (si.properties [&quot;node.id&quot;]))
    local client_ids = {}

    for id, node in pairs (node_group) do
      local media_class = tostring(node.properties [&quot;media.class&quot;])
      if media_class:find (&quot;^Stream/Output&quot;) then
        client_ids [node.properties [&quot;client.id&quot;]] = true
      end
    end

    -- find players to handle
    local pause_players = {}

    for client_id in pairs (client_ids) do
      local client = client_om:lookup {
        Constraint { &quot;bound-id&quot;, &quot;=&quot;, client_id, type = &quot;gobject&quot; }
      }
      if not client then
        goto next
      end

      log:debug (si, string.format (&quot;node %s removed: was linked to client %s (%s pid %s)&quot;,
          tostring(si.properties [&quot;node.id&quot;]),
          tostring(client.properties [&quot;application.name&quot;]),
          tostring(client.properties [&quot;application.id&quot;]),
          tostring(client.properties [&quot;application.process.id&quot;])))

      for _, player in ipairs(players) do
        local match = false

        if client.properties [&quot;pipewire.access.portal.app_id&quot;] == nil and player [&quot;flatpak-app-id&quot;] == nil then
          -- assume non-flatpak apps serve audio from same or child process as MPRIS
          if player [&quot;pid&quot;] ~= nil then
            local keys = { &quot;pipewire.sec.pid&quot;, &quot;application.process.id&quot; }
            for _, key in ipairs(keys) do
              local pid = tonumber (client.properties [key])
              if pid ~= nil and mpris:call (&quot;match-pid&quot;, player [&quot;pid&quot;], pid) then
                log:debug (si, string.format(&quot;.. match %s %u ~ %u&quot;, key, pid, player [&quot;pid&quot;]))
                match = true
              end
            end
          end
        elseif client.properties [&quot;pipewire.access.portal.app_id&quot;] == player [&quot;flatpak-app-id&quot;] then
          local instance_id = client.properties [&quot;pipewire.access.portal.instance_id&quot;]
          if instance_id == nil then
            -- Only new Pipewire versions have instance_id
            log:debug (si, string.format(&quot;.. match pipewire.access.portal.app_id = %s&quot;, player [&quot;flatpak-app-id&quot;]))
            match = true
          elseif instance_id == player [&quot;flatpak-instance-id&quot;] then
            log:debug (si, string.format(&quot;.. match pipewire.access.portal.app_id = %s instance_id = %s&quot;,
                player [&quot;flatpak-app-id&quot;], player [&quot;flatpak-instance-id&quot;]))
            match = true
          end
        end

        if match then
          pause_players [player [&quot;name&quot;]] = true
        end
      end

      ::next::
    end

    -- handle players
    for bus_name in pairs(pause_players) do
      log:info (si, string.format(&quot;node %s removed: pausing linked media player %s&quot;,
          tostring(si.properties [&quot;node.id&quot;]),
          bus_name))

      local op = mpris:call (&quot;pause&quot;, bus_name)
      if op [&quot;result&quot;] == 0 then
        log:debug (&quot;pause pending&quot;)
        pending_ops = pending_ops + 1
        op:connect(&quot;notify::result&quot;, function (op, pspec)
            if pending_ops &gt; 0 then
              pending_ops = pending_ops - 1
            end
            log:debug (string.format(&quot;pause completed, res = %d, %d remaining&quot;,
                op [&quot;result&quot;], pending_ops))
            if pending_ops == 0 and need_rescan then
              -- Some players respond to DBus before actually pausing output,
              -- so add also a small delay
              Core.timeout_add(RESCAN_DELAY_MSEC, function()
                  log:debug (&quot;continue rescan&quot;)
                  source:call (&quot;push-event&quot;, &quot;rescan-for-linking&quot;, nil, nil)
              end)
            end
        end)
      end
    end
  end
}

-- Do not perform rescans while we are pausing media players
rescan_hook = SimpleEventHook {
  name = &quot;linking/mpris-pause-disable-rescan&quot;,
  before = &quot;linking/rescan&quot;,
  interests = {
    EventInterest {
      Constraint { &quot;event.type&quot;, &quot;=&quot;, &quot;rescan-for-linking&quot; },
    },
  },
  execute = function (event)
    if pending_ops &gt; 0 then
      log:info (&quot;rescan disabled, wait for pending operations&quot;)
      need_rescan = true
      event:stop_processing ()
    else
      need_rescan = false
    end
  end
}


function updateEnabled ()
  local enable = Settings.get_boolean (&quot;linking.pause-playback&quot;)

  log:debug (string.format (&quot;enabled: %s&quot;, tostring(enable)))

  if enable and not script_active then
    local source = Plugin.find (&quot;standard-event-source&quot;)
    initializeState ()
    initializeLinks (source)
    link_hook:register ()
    pause_hook:register ()
    rescan_hook:register ()
    script_active = true
  elseif not enable and script_active then
    link_hook:remove ()
    pause_hook:remove ()
    rescan_hook:remove ()
    if need_rescan then
      local source = Plugin.find (&quot;standard-event-source&quot;)
      source:call (&quot;push-event&quot;, &quot;rescan-for-linking&quot;, nil, nil)
    end
    initializeState ()
  end
end

Settings.subscribe (&quot;linking.pause-playback&quot;, updateEnabled)
updateEnabled ()
</textarea><br><input type="hidden" name="edit_file" value="mpris-pause.lua"><input type="submit" value="Save"></form>