Comment puis-je exécuter un programme au démarrage, minimisé?

Je veux juste que Telegram soit exécuté et je l'ai ajouté aux applications de démarrage. Le fait est que j'ai besoin que cela soit minimisé. Des commandes?

Démarrage d'une application minimisé

Le démarrage d'une application de manière minimisée nécessite deux commandes:

• démarrage de l'application
• minimiser sa fenêtre

Par conséquent, la commande ou le script doit être "intelligent"; la deuxième commande doit attendre que la fenêtre de l'application s'affiche réellement.

Solution générale pour démarrer une application minimisée

Le script ci-dessous fait cela et peut être utilisé comme solution générale pour démarrer une application de manière minimisée. Il suffit de l'exécuter dans la syntaxe:

<script> <command_to_run_the_application> <window_name>

Le script

#!/usr/bin/env python3
import subprocess
import sys
import time

subprocess.Popen(["/bin/bash", "-c", sys.argv[1]])
windowname = sys.argv[2]

def read_wlist(w_name):
    try:
        l = subprocess.check_output(["wmctrl", "-l"]).decode("utf-8").splitlines()
        return [w.split()[0] for w in l if w_name in w][0]
    except (IndexError, subprocess.CalledProcessError):
        return None

t = 0
while t < 30:
    window = read_wlist(windowname)
    time.sleep(0.1)
    if window != None:
        subprocess.Popen(["xdotool", "windowminimize", window])
        break
    time.sleep(1)
    t += 1

Comment utiliser

Le script a besoin des deux wmctrlet xdotool:

sudo apt-get install wmctrl xdotool

Alors:

1. Copiez le script dans un fichier vide, enregistrez-le sous startup_minimizd.py

2. Testez-exécutez le script avec (par exemple) geditla commande:

   python3 /path/to/startup_minimizd.py gedit gedit
   

3. Si tout fonctionne bien, ajoutez la commande (pour votre application) à Startup Applications

Explication

• Le script démarre l'application, exécutant la commande que vous avez donnée comme premier argument
• Ensuite, le script vérifie la liste des fenêtres (à l'aide de wmctrl) pour les fenêtres, nommées d'après votre deuxième argument.
• Si la fenêtre apparaît, elle est immédiatement réduite à l'aide de xdotool Pour empêcher une boucle sans fin si la fenêtre ne s'affiche pas pour une raison quelconque, le script applique un délai de 30 secondes pour que la fenêtre s'affiche.

Remarque

Inutile de mentionner que vous pouvez utiliser le script pour plusieurs applications à la fois, car vous l'exécutez avec des arguments en dehors du script.

ÉDITER

reconnaître la fenêtre par son pid

Si le titre de la fenêtre est incertain ou variable, ou s'il existe un risque de conflits de noms dans le nom de la fenêtre, l'utilisation de la pidest une méthode plus fiable à utiliser.

Le script ci-dessous est basé sur l'utilisation du pid de l'application, comme dans la sortie des deux wmctrl -lpet ps -ef.

La configuration est à peu près la même, mais le titre de la fenêtre n'est pas nécessaire dans cette version, donc la commande pour l'exécuter est:

python3 /path/to/startup_minimizd.py <command_to_run_application>

Tout comme le premier script, il a besoin des deux wmctrletxdotool

Le script

#!/usr/bin/env python3
import subprocess
import sys
import time

command = sys.argv[1]
command_check = command.split("/")[-1]

subprocess.Popen(["/bin/bash", "-c", command])

t = 1
while t < 30:
    try:
        w_list = [l.split() for l in subprocess.check_output(["wmctrl", "-lp"]).decode("utf-8").splitlines()]
        proc = subprocess.check_output(["pgrep", "-f", command_check]).decode("utf-8").strip().split()
        match = sum([[l[0] for l in w_list if p in l] for p in proc], [])
        subprocess.Popen(["xdotool", "windowminimize", match[0]])
        break
    except (IndexError, subprocess.CalledProcessError):
        pass
    t += 1
    time.sleep(1)

Remarque sur le deuxième script

Bien qu'en général la deuxième version devrait être plus fiable, dans les cas où l'application est démarrée par un script wrapper, le pid de la commande sera différent de l'application qui est finalement appelée.

Dans de tels cas, je recommande d'utiliser le premier script.

EDIT2 une version spécifique du script pour Steam

Comme demandé dans un commentaire, ci-dessous une version, spécialement conçue pour le démarrage de STEAM minimisé.

Pourquoi une version spécifique pour Steam?

Il s'avère que le Steamcomportement est assez différent d'une application "normale":

• Il s'avère Steamne fonctionne pas un pid, mais pas moins (dans mon test) huit!
• Steams'exécute au démarrage avec au moins deux fenêtres (une fenêtre semblable à une éclaboussure), mais parfois une fenêtre de message supplémentaire apparaît.
• Les fenêtres de Steam ont pid 0, ce qui est un problème dans le script tel qu'il était.
• Une fois la fenêtre principale créée, la fenêtre est augmentée une deuxième fois après une seconde environ, de sorte qu'une seule minimisation ne suffira pas.

Ce comportement exceptionnel de Steamdemande une version spéciale du script, qui est ajoutée ci-dessous. Le script démarre Steam, et pendant 12 secondes, il garde un œil sur toutes les nouvelles fenêtres du correspondant WM_CLASS, vérifiant si elles sont minimisées. Sinon, le script s'assure qu'ils le seront.

Comme le script d'origine, celui-ci a besoin wmctrlet xdotooldoit être installé.

Le script

#!/usr/bin/env python3
import subprocess
import time

command = "steam"
subprocess.Popen(["/bin/bash", "-c", command])

def get(cmd):
    return subprocess.check_output(cmd).decode("utf-8").strip()

t = 0

while t < 12:
    try:
        w_list = [l.split()[0] for l in get(["wmctrl", "-l"]).splitlines()]
        for w in w_list:
            data = get(["xprop", "-id", w])
            if all(["Steam" in data, not "_NET_WM_STATE_HIDDEN" in data]):
                subprocess.Popen(["xdotool", "windowminimize", w])
    except (IndexError, subprocess.CalledProcessError):
        pass

    t += 1
    time.sleep(1)

Pour l'utiliser

• Copiez-le simplement dans un fichier vide, enregistrez-le sous runsteam_minimized.py

• Exécutez-le par la commande:

  python3 /path/to/runsteam_minimized.py
  

Il est bon d'avoir les scripts fournis par user72216 et Sergey comme solutions générales au problème, mais parfois l'application que vous souhaitez démarrer minimisée dispose déjà d'un commutateur qui fera ce que vous voulez.

Voici quelques exemples avec les chaînes de commande du programme de démarrage correspondantes:

• Telegram (depuis la version 0.7.10) a l' -startintrayoption:<path-to-Telegram>/Telegram -startintray
• Steam a l' -silentoption:/usr/bin/steam %U -silent
• La transmission a l' --minimizedoption:/usr/bin/transmission-gtk --minimized

Dans Unity, ces applications démarrent sous forme d'icônes dans la barre de menu supérieure plutôt que sous forme d'icônes sur le lanceur, bien que l'icône de lancement normale apparaisse toujours une fois que vous commencez à utiliser l'application. D'autres applications peuvent se comporter différemment.

J'ai pris les scripts de Jacob et les ai modifiés un peu pour les rendre plus universels.

#!/usr/bin/python

import os
import subprocess
import sys
import time
import signal

WAIT_TIME = 10


def check_exist(name):
    return subprocess.Popen("which "+name,
                            shell=True,
                            stdout=subprocess.PIPE
                            ).stdout.read().rstrip("-n")


def killpid(pidlist):
    for pid in pidlist:
        args = ["xdotool",
                "search",
                "--any",
                "--pid",
                pid,
                "--name",
                "notarealprogramname",
                "windowunmap",
                "--sync",
                "%@"]
        subprocess.Popen(args)


def killname(name):
    args = ["xdotool",
            "search",
            "--any",
            "--name",
            "--class",
            "--classname",
            name,
            "windowunmap",
            "--sync",
            "%@"]
    subprocess.Popen(args)


sys.argv.pop(0)

if check_exist(sys.argv[0]) == "":
    sys.exit(1)
if check_exist("xdotool") == "":
    sys.stderr.write("xdotool is not installed\n")
    sys.exit(1)
if check_exist("wmctrl") == "":
    sys.stderr.write("wmctrl is not installed\n")
    sys.exit(1)

try:
    prog = subprocess.Popen(sys.argv, preexec_fn=os.setsid)
except OSError, e:
    sys.exit(1)

time.sleep(WAIT_TIME)
idlist = subprocess.Popen("pgrep -g " + str(prog.pid),
                          shell=True,
                          stdout=subprocess.PIPE
                          ).stdout.read().splitlines()

ps1 = os.fork()
if ps1 > 0:
    ps2 = os.fork()

if ps1 == 0:  # Child 1
    os.setpgid(os.getpid(), os.getpid())
    killpid(idlist)
    sys.exit(0)
elif ps2 == 0:  # Child 2
    killname(os.path.basename(sys.argv[0]))
    sys.exit(0)
elif ps1 > 0 and ps2 > 0:  # Parent
    time.sleep(WAIT_TIME)
    os.killpg(os.getpgid(int(ps1)), signal.SIGTERM)
    os.kill(ps2, signal.SIGTERM)
    os.waitpid(ps1, 0)
    os.waitpid(ps2, 0)
    sys.exit(0)
else:
    exit(1)

Les principales différences sont les suivantes:

• Le programme définit l'ID de groupe (GID) pour le processus. Ainsi, tous les processus enfants et leurs fenêtres peuvent être facilement trouvés
• L'option xdotool --sync est utilisée à la place d'une boucle while
• Le script permet de passer des arguments au programme

WAIT_TIME doit être défini suffisamment grand pour permettre au programme de bifurquer ses processus enfants. Sur mon ordinateur, c'est suffisant pour les gros programmes comme Steam. Augmentez-le si nécessaire.

Une addition

xdotoolL'option windowunmappeut fonctionner de manière géniale avec certaines applications et programmes de bacs (bac de Linux Mint, par exemple), voici donc une version alternative du script pour ces exceptions.

#!/usr/bin/python

import os
import subprocess
import sys
import time
import signal

WAIT_TIME = 10


def check_exist(name):
    return subprocess.Popen("which "+name,
                            shell=True,
                            stdout=subprocess.PIPE
                            ).stdout.read().rstrip("-n")


def killpid(pidlist):
    for pid in pidlist:
        args = ["xdotool",
                "search",
                "--sync",
                "--pid",
                pid]
        for i in subprocess.Popen(args,
                                  stdout=subprocess.PIPE).\
                stdout.read().splitlines():
            if i != "":
                subprocess.Popen("wmctrl -i -c " +
                                 hex(int(i)), shell=True)


def killname(name):
    args = ["xdotool",
            "search",
            "--sync",
            "--any",
            "--name",
            "--class",
            "--classname",
            name]
    for i in subprocess.Popen(args,
                              preexec_fn=os.setsid,
                              stdout=subprocess.PIPE)\
            .stdout.read().splitlines():
        if i != "":
            subprocess.Popen("wmctrl -i -c " + hex(int(i)),
                             shell=True)


sys.argv.pop(0)

if check_exist(sys.argv[0]) == "":
    sys.exit(1)
if check_exist("xdotool") == "":
    sys.stderr.write("xdotool is not installed\n")
    sys.exit(1)
if check_exist("wmctrl") == "":
    sys.stderr.write("wmctrl is not installed\n")
    sys.exit(1)


try:
    prog = subprocess.Popen(sys.argv, preexec_fn=os.setsid)
except OSError, e:
    sys.exit(1)

time.sleep(WAIT_TIME)
idlist = subprocess.Popen("pgrep -g " + str(prog.pid),
                          shell=True,
                          stdout=subprocess.PIPE
                          ).stdout.read().splitlines()

ps1 = os.fork()
if ps1 > 0:
    ps2 = os.fork()

if ps1 == 0:  # Child 1
    os.setpgid(os.getpid(), os.getpid())
    killpid(idlist)
    sys.exit(0)
elif ps2 == 0:  # Child 2
    killname(os.path.basename(sys.argv[0]))
    sys.exit(0)
elif ps1 > 0 and ps2 > 0:  # Parent
    time.sleep(WAIT_TIME)
    os.killpg(os.getpgid(int(ps1)), signal.SIGTERM)
    os.kill(ps2, signal.SIGTERM)
    os.waitpid(ps1, 0)
    os.waitpid(ps2, 0)
    sys.exit(0)
else:
    exit(1)

Si le programme est fermé sur le plateau, on peut en fait vouloir fermer la fenêtre du programme au démarrage au lieu de la minimiser. Un exemple d'un tel programme est Viber. Dans ce cas, on pourrait utiliser le script suivant start_closed.sh:

#!/bin/bash

# Check that there is only one input argument
if [[ $# -gt 1 ]]; then
echo "Usage: $0 <program-to-start>"
exit 1
fi

$1 &                               # Start program passed in first argument
pid=$!                             # Get PID of last started program
xdotool search --sync --pid $pid | # Wait for window with PID to appear...
xargs wmctrl -i -c                 # ...and close it

Usage: <path-to-script> <program-to-start>

Je surfais et suis tombé sur cette question, alors je me demandais quel est votre système d'exploitation? Quant à moi, j'utilise UBUNTU BUDGIE 18.04 LTS donc dans ce système d'exploitation c'est très simple.

Allez simplement au menu

Dans le menu, accédez aux paramètres de Budgie Desktop

et

À partir de Desktop Setting, accédez à Auto Start

Il vous donnera 2 options, de "+" ajouter

1. Ajouter une application

2. Ajouter une commande

En sélectionnant Ajouter une application, toutes les applications seront répertoriées, sélectionnez n'importe quelle application que vous souhaitez et elle démarrera lorsque vous démarrez votre ordinateur et elle sera également minimisée.

J'avais besoin que les programmes soient fermés au plateau, pas minimisés, et j'ai essayé tous les scripts affichés ici, ceux qui fonctionnaient, ne fonctionnaient que pour certains programmes et pas pour d'autres. J'ai donc codé celui qui fonctionne beaucoup mieux (vous ne voyez presque pas la fenêtre apparaître, seulement l'icône de la barre d'état, il semble natif) et fonctionne pour tous les programmes que j'ai essayés. Il est basé sur celui de Jacob. Avec ce script, vous devrez peut-être ajouter un argument en fonction du programme (voir ci-dessous), mais a toujours fonctionné pour moi avec de nombreux programmes, il devrait également fonctionner avec Steam.

Usage:

1. sudo apt-get install wmctrl xdotool
2. Enregistrez le script en tant que startup_closed.pylui donner des autorisations d'exécution, puis exécutezpython3 ./startup_closed.py -c <command to open program>
3. Si l'icône de la barre des programmes ne s'affiche pas ou que la fenêtre ne s'affiche pas, vous devez ajouter l'un de ces arguments: -splashou -hide, par essais et erreurs. Par exemple: python3 ./startup_closed.py -hide -c teamvieweroupython3 ./startup_closed.py -splash -c slack
4. Il y a plus d'arguments mais vous n'en avez probablement pas besoin. Il y a aussi des détails complets sur quand et pourquoi les arguments sont nécessaires dans l'aide:./startup_closed.py --help

Scénario:

#!/usr/bin/env python3
import subprocess
import sys
import time
import argparse
import random

parser = argparse.ArgumentParser(description='This script executes a command you specify and closes or hides the window/s that opens from it, leaving only the tray icon. Useful to "open closed to tray" a program. If the program does not have a tray icon then it just gets closed. There is no magic solution to achieve this that works for all the programs, so you may need to tweek a couple of arguments to make it work for your program, a couple of trial and error may be required with the arguments -splash and -hide, you probably will not need the others.')

parser.add_argument("-c", type=str, help="The command to open your program. This parameter is required.", required=True)
parser.add_argument("-splash", help="Does not close the first screen detected. Closes the second window detected. Use in programs that opens an independent splash screen. Otherwise the splash screen gets closed and the program cannot start.", action='store_true', default=False)
parser.add_argument("-hide", help="Hides instead of closing, for you is the same but some programs needs this for the tray icon to appear.", action='store_true', default=False)
parser.add_argument("-skip", type=int, default=0, help='Skips the ammount of windows specified. For example if you set -skip 2 then the first 2 windows that appear from the program will not be affected, use it in programs that opens multiple screens and not all must be closed. The -splash argument just increments by 1 this argument.', required=False)
parser.add_argument("-repeat", type=int, default=1, help='The amount of times the window will be closed or hidden. Default = 1. Use it for programs that opens multiple windows to be closed or hidden.', required=False)
parser.add_argument("-delay", type=float, default=10, help="Delay in seconds to wait before running the application, useful at boot to not choke the computer. Default = 10", required=False)
parser.add_argument("-speed", type=float, default=0.02, help="Delay in seconds to wait between closing attempts, multiple frequent attempts are required because the application may be still loading Default = 0.02", required=False)

args = parser.parse_args()

if args.delay > 0:
    finalWaitTime = random.randint(args.delay, args.delay * 2);
    print(str(args.delay) + " seconds of delay configured, will wait for: " + str(finalWaitTime))
    time.sleep(finalWaitTime)
    print("waiting finished, running the application command...")

command_check = args.c.split("/")[-1]
subprocess.Popen(["/bin/bash", "-c", args.c])

hasIndependentSplashScreen = args.splash
onlyHide = args.hide
skip = args.skip
repeatAmmount = args.repeat
speed = args.speed

actionsPerformed = 0
lastWindowId = 0

if hasIndependentSplashScreen:
    skip += 1

while True:
    try:
        w_list = [l.split() for l in subprocess.check_output(["wmctrl", "-lp"]).decode("utf-8").splitlines()]
        proc = subprocess.check_output(["pgrep", "-f", command_check]).decode("utf-8").strip().split()
        match = sum([[l[0] for l in w_list if p in l] for p in proc], [])
        if len(match) > 0:
            windowId = match[0]
            if windowId != lastWindowId:
                if skip > 0:
                    skip -= 1
                    print("skipped window: " + windowId)
                    lastWindowId = windowId
                else:
                    print("new window detected: " + windowId)
                    if onlyHide:
                        subprocess.Popen(["xdotool", "windowunmap", windowId])
                        print("window was hidden: " + windowId)
                    else:
                        subprocess.Popen(["xdotool", "key", windowId, "alt+F4"])
                        print("window was closed: " + windowId)

                    actionsPerformed += 1
                    lastWindowId = windowId

            if actionsPerformed == repeatAmmount:
                break

    except (IndexError, subprocess.CalledProcessError):
        break

    time.sleep(speed)

print("finished")

Je suis venu avec une solution plutôt élégante qui repose exclusivement sur xdotool, et elle est très utile pour les applications qui n'ont pas d' argument "démarrage minimisé" , comme Telegram.

Le seul inconvénient est que la solution doit être conçue manuellement pour chaque application, mais en supposant que ce n'est pas un problème (par exemple: si vous souhaitez démarrer automatiquement une certaine application sans lui permettre de polluer votre écran après la connexion) , c'est beaucoup plus simple et direct. .

Exemples réels

## Starts Telegram and immediately closes it
xdotool search --sync --onlyvisible --name '^Telegram$' windowclose &
telegram-desktop &

## Starts WhatsApp and immediately closes it
xdotool search --sync --onlyvisible --name '(\([0-9]*\) ){0,1}(WhatsApp$|WhatsApp Web$)' windowclose &
whatsapp-nativefier &

La solution

À première vue, vous pourriez penser qu'il est préférable d'utiliser le PID ou la classe du processus pour faire la comparaison, mais c'est en fait contre-productif car vous obtiendrez fréquemment plusieurs résultats pour le même PID. Les exemples sont une fenêtre 0x0 qui attend réellement une notification, une icône systray ou toute autre fenêtre "cachée".

La solution consiste à créer une commande xdotool qui ne renvoie toujours qu'une seule fenêtre unique . Dans mes deux exemples, cela a été fait en utilisant --name, cependant vous pouvez combiner plusieurs sélecteurs avec --all (par exemple: faire correspondre un nom de classe donné + un nom de classe + une expression régulière de nom) . Habituellement, une bonne --nameexpression régulière fait l'affaire.

Après avoir créé vos searchconditions, générez simplement une instance de xdotool (détachée du shell) avec le --syncparamètre et vos conditions, suivi de windowclose. Exécutez ensuite votre application:

xdotool search --sync [... myapp-match-conditions] windowclose &
my-app

Découvrez xdotool search --helptoutes les possibilités de combinaisons que vous pouvez organiser pour pouvoir cibler la fenêtre exacte que vous souhaitez. Parfois, cela devient difficile et vous devez combiner plusieurs conditions, mais une fois que vous avez terminé, cela échouera rarement (à moins qu'une mise à jour ne modifie l'application et ne casse votre implémentation, bien sûr).