Como detectar o ambiente da área de trabalho em um script bash?

Question

Estou escrevendo um script bash que precisa saber qual ambiente de área de trabalho (XFCE, Unity, KDE, LXDE, Mate, Canela, GNOME2, GNOME3, ...) está sendo executado.

Como posso obter essa informação?

    

Answer 1

O principal problema com a verificação do DESKTOP_SESSION é que ele é definido pelo gerenciador de exibição em vez da sessão da área de trabalho e está sujeito a inconsistências. Para lightdm no Debian, os valores vêm dos nomes dos arquivos em /usr/share/xsessions/ . DESKTOP_SESSION reflete o ambiente de área de trabalho se uma seleção específica for feita no login, no entanto, o lightdm-xsession é sempre usado na sessão padrão.

GDMSESSION é outra opção, mas parece ter uma situação semelhante (é o mesmo valor que DESKTOP_SESSION para mim).

XDG_CURRENT_DESKTOP parece ser uma boa escolha, no entanto, ainda não está no padrão XDG e, portanto, nem sempre implementado. Veja aqui para uma discussão sobre isso. Esta resposta mostra seus valores para diferentes distros / desktops, eu também posso confirmar que ela não está disponível no XFCE.

O substituto razoável para XDG_CURRENT_DESKTOP não existente seria tentar XDG_DATA_DIRS . Desde que os arquivos de dados para o ambiente de desktop estejam instalados em um diretório com seu nome, essa abordagem deve funcionar. Espero que seja esse o caso de todas as distros / desktops!

Os seguintes testes (com o GNU grep) para XFCE, KDE e Gnome:

echo "$XDG_DATA_DIRS" | grep -Eo 'xfce|kde|gnome'

compatível com POSIX:

echo "$XDG_DATA_DIRS" | sed 's/.*\(xfce\|kde\|gnome\).*//'

Para combinar com a verificação de XDG_CURRENT_DESKTOP :

if [ "$XDG_CURRENT_DESKTOP" = "" ]
then
  desktop=$(echo "$XDG_DATA_DIRS" | sed 's/.*\(xfce\|kde\|gnome\).*//')
else
  desktop=$XDG_CURRENT_DESKTOP
fi

desktop=${desktop,,}  # convert to lower case
echo "$desktop"

    

Answer 2

Método 1 - $ DESKTOP_SESSION

Acho que você pode descobrir interrogando a variável de ambiente $DESKTOP_SESSION . Não estou totalmente certo de quão amplamente suportado isso é, mas nos meus testes limitados parece estar disponível no Fedora & Ubuntu.

$ echo $DESKTOP_SESSION
gnome

Outra opção é a variável $XDG_SESSION_DESKTOP .

Método 2 - wmctrl

Existe também este método que faz uso de wmctrl .

$ wmctrl  -m
Name: GNOME Shell
Class: N/A
PID: N/A
Window manager's "showing the desktop" mode: N/A

Referências

• Como determinar qual gerenciador de janelas está sendo executado

Answer 3

Você pode usar este script bash . Ele pode detectar o nome e a versão do ambiente de área de trabalho.

#!/bin/bash

function detect_gnome()
{
    ps -e | grep -E '^.* gnome-session$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION='gnome-session --version | awk '{print $2}''
    DESKTOP="GNOME"
    return 1
}

function detect_kde()
{
    ps -e | grep -E '^.* kded4$' > /dev/null
    if [ $? -ne 0 ];
    then
        return 0
    else    
        VERSION='kded4 --version | grep -m 1 'KDE' | awk -F ':' '{print $2}' | awk '{print $1}''
        DESKTOP="KDE"
        return 1
    fi
}

function detect_unity()
{
    ps -e | grep -E 'unity-panel' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION='unity --version | awk '{print $2}''
    DESKTOP="UNITY"
    return 1
}

function detect_xfce()
{
    ps -e | grep -E '^.* xfce4-session$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION='xfce4-session --version | grep xfce4-session | awk '{print $2}''
    DESKTOP="XFCE"
    return 1
}

function detect_cinnamon()
{
    ps -e | grep -E '^.* cinnamon$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION='cinnamon --version | awk '{print $2}''
    DESKTOP="CINNAMON"
    return 1
}

function detect_mate()
{
    ps -e | grep -E '^.* mate-panel$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi
    VERSION='mate-about --version | awk '{print $4}''
    DESKTOP="MATE"
    return 1
}

function detect_lxde()
{
    ps -e | grep -E '^.* lxsession$' > /dev/null
    if [ $? -ne 0 ];
    then
    return 0
    fi

    # We can detect LXDE version only thru package manager
    which apt-cache > /dev/null 2> /dev/null
    if [ $? -ne 0 ];
    then
    which yum > /dev/null 2> /dev/null
    if [ $? -ne 0 ];
    then
        VERSION='UNKNOWN'
    else
        # For Fedora
        VERSION='yum list lxde-common | grep lxde-common | awk '{print $2}' | awk -F '-' '{print $1}''
    fi
    else    
    # For Lubuntu and Knoppix
    VERSION='apt-cache show lxde-common /| grep 'Version:' | awk '{print $2}' | awk -F '-' '{print $1}''
    fi
    DESKTOP="LXDE"
    return 1
}

function detect_sugar()
{
    if [ "$DESKTOP_SESSION" == "sugar" ];
    then
    VERSION='python -c "from jarabe import config; print config.version"'
    DESKTOP="SUGAR"
    else
    return 0
    fi
}


DESKTOP="UNKNOWN"
if detect_unity;
then
    if detect_kde;
    then
    if detect_gnome;
    then
        if detect_xfce;
        then
        if detect_cinnamon;
        then
            if detect_mate;
            then
            if detect_lxde;
            then
                detect_sugar
            fi
            fi
        fi
        fi
    fi
    fi
fi


if [ "$1" == '-v' ];
then
    echo $VERSION
else
    if [ "$1" == '-n' ];
    then
    echo $DESKTOP
    else
    echo $DESKTOP $VERSION
    fi
fi

    

Answer 4

Isso provavelmente depende da situação. Se você souber qual gerenciador de exibição é usado, pode ser que este coloque essa informação em uma variável de ambiente.

Se esse não for o caso, acho que você deve verificar todas as DE que deseja identificar. Todos eles devem introduzir suas próprias variáveis de ambiente.

    

Answer 5

Se a variável ambiental XDG_CURRENT_DESKTOP estiver disponível, ele deverá informar.

# echo $XDG_CURRENT_DESKTOP
KDE

    

Answer 6

Você pode procurar por Xorg dos processos. O pai disso deve ser o seu gerenciador de exibição. Seus descendentes devem dar uma indicação de qual ambiente de desktop está sendo executado. No meu sistema, o gerenciador de exibição é executado (com parâmetros diferentes). Isso então gera x-session-manager , que é vinculado a xfce4-session . Isso pode ser suficiente, mas todos os filhos disso estão relacionados ao meu ambiente de área de trabalho. Encontrá-los através da árvore de processos deve ser a melhor maneira de excluir elementos de outros sistemas de janelas iniciados por vários programas (ou talvez deliberadamente).

Meu primeiro pensamento foi que seria melhor procurar pelo gerenciador de janelas associado ao seu ambiente de desktop, mas muitas vezes um gerenciador de janelas pode ser configurado para rodar (por exemplo, xmonad no Gnome), então isso não é robusto. O melhor para procurar é provavelmente aquele que gerencia a área de trabalho real, por exemplo, xfdesktop ou qualquer elemento do ambiente de área de trabalho que você realmente precise para o seu script funcionar:)

Exemplo

Aqui está um exemplo usando procps-ng ( -C e --ppid não são POSIX). Assume que é apenas uma instância de Xorg .

Este é apenas um exemplo que funciona para o desktop do xfce. Um exemplo de trabalho completo requer uma investigação nos processos que cada sistema de desktop usa, assim como a maioria das outras soluções exigem investigação sobre como as variáveis ambientais são definidas em vários outros sistemas de desktop.

X=Xorg

search_descendants ()
{
  ps h -o comm --ppid $1 |
    grep -E '^(xfdesktop|another_desktop_process)$' &&
    return 0

  for pid in $(ps h -o pid --ppid $1)
  do
    search_descendants $pid && return 0
  done

  return 1
}

dm_pid=$(ps h -o ppid -C "$X")

case "$(search_descendants $dm_pid)" in
  xfdesktop)
    desktop=xfce
    ;;
  another_desktop_process)
    desktop=another_desktop
    ;;
  *)
    desktop=unknown
    ;;
esac

echo $desktop

    

Answer 7

De todas as experiências relatadas nos inúmeros comentários, acho que é meu dever como OP encontrar uma resposta consensual. (Fique tranqüilo, eu ficaria feliz em rever esta resposta, caso os dados de contraste se tornem disponíveis.)

Por enquanto, parece melhor ter a nossa liderança em $XDG_CURRENT_DESKTOP quando esta variável é definida. Caso contrário, $XDG_DATA_DIRS pode fornecer as informações desejadas, mais do que a primeira letra de ${DESKTOP_SESSION:0:1} .