Jak mogę zminimalizować program przy uruchamianiu?

Chcę tylko uruchomić Telegram i dodałem go do aplikacji startowych. Chodzi o to, że muszę to zminimalizować. Jakieś polecenia?

Zminimalizowane uruchomienie aplikacji

Uruchomienie aplikacji w zminimalizowany sposób wymaga dwóch poleceń:

• uruchomienie aplikacji
• zminimalizuj jego okno

Dlatego polecenie lub skrypt musi być „inteligentny”; drugie polecenie powinno zaczekać na pojawienie się okna aplikacji.

Ogólne rozwiązanie do uruchamiania aplikacji zminimalizowane

Poniższy skrypt to robi i może być używany jako ogólne rozwiązanie do uruchamiania aplikacji w zminimalizowany sposób. Po prostu uruchom go w składni:

<script> <command_to_run_the_application> <window_name>

Scenariusz

#!/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

Jak używać

Skrypt potrzebuje zarówno wmctrla xdotool:

sudo apt-get install wmctrl xdotool

Następnie:

1. Skopiuj skrypt do pustego pliku i zapisz go jako startup_minimizd.py

2. Testuj - uruchom skrypt za pomocą (np.) geditPolecenia:

   python3 /path/to/startup_minimizd.py gedit gedit
   

3. Jeśli wszystko działa poprawnie, dodaj polecenie (dla swojej aplikacji) do Startup Applications

Wyjaśnienie

• Skrypt uruchamia aplikację, uruchamiając polecenie podane jako pierwszy argument
• Następnie skrypt sprawdza listę okien (przy pomocy wmctrl) pod kątem okien, nazwanych na podstawie drugiego argumentu.
• Jeśli okno się pojawi, zostanie ono natychmiast zminimalizowane za pomocą xdotool Aby zapobiec niekończącej się pętli, jeśli okno może się nie pojawić z jakiegoś powodu, skrypt przestrzega limitu czasu 30 sekund na pojawienie się okna.

Uwaga

Nie trzeba wspominać, że możesz używać skryptu dla wielu aplikacji jednocześnie, ponieważ uruchamiasz go z argumentami spoza skryptu.

EDYTOWAĆ

rozpoznawanie okna po pid

Jeśli tytuł okna jest niepewny lub zmienny, lub istnieje ryzyko kolizji nazwy w nazwie okna, użycie pidbardziej niezawodnej metody jest możliwe.

Poniższy skrypt opiera się na wykorzystaniu pid aplikacji, tak jak w danych wyjściowych zarówno wmctrl -lpi ps -ef.

Konfiguracja jest prawie taka sama, ale tytuł okna nie jest potrzebny w tej wersji, więc polecenie do uruchomienia to:

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

Podobnie jak pierwszy skrypt, potrzebuje zarówno wmctrlixdotool

Scenariusz

#!/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)

Uwaga na drugi skrypt

Chociaż ogólnie druga wersja powinna być bardziej niezawodna, w przypadkach, gdy aplikacja jest uruchamiana przez skrypt otoki, pid polecenia będzie różny od aplikacji, która jest ostatecznie wywoływana.

W takich przypadkach zalecam użycie pierwszego skryptu.

EDYCJA 2 konkretną wersję skryptu dla Steam

Zgodnie z żądaniem w komentarzu, poniżej wersji specjalnie zminimalizowanej do uruchomienia STEAM.

Dlaczego konkretna wersja dla Steam?

Okazuje się, że Steamzachowuje się zupełnie inaczej niż „normalna” aplikacja:

• Okazuje się, Steamże nie działa jeden pid, ale nie mniej niż (w moim teście) osiem!
• Steamuruchamia się przy uruchamianiu z co najmniej dwoma oknami (jednym oknem przypominającym ekran powitalny), ale czasami pojawia się dodatkowe okno komunikatu.
• Windows Steam ma pid 0, co jest problemem w skrypcie.
• Po utworzeniu okna głównego okno jest podnoszone po raz drugi po upływie około jednej sekundy, więc pojedyncze minimalizowanie się nie powiedzie.

To wyjątkowe zachowanie Steamwymaga specjalnej wersji skryptu, która została dodana poniżej. Skrypt uruchamia się Steami przez 12 sekund obserwuje wszystkie nowe okna odpowiednich WM_CLASS, sprawdzając, czy są zminimalizowane. Jeśli nie, skrypt upewni się, że tak będzie.

Podobnie jak w przypadku oryginalnego skryptu, ten potrzebuje wmctrli xdotooldo zainstalowania.

Scenariusz

#!/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)

Aby go użyć

• Po prostu skopiuj go do pustego pliku i zapisz jako runsteam_minimized.py

• Uruchom go za pomocą polecenia:

  python3 /path/to/runsteam_minimized.py
  

Dobrze jest mieć skrypty podane przez user72216 i Siergieja jako ogólne rozwiązania problemu, ale czasami aplikacja, którą chcesz uruchomić, zminimalizowana ma już przełącznik, który zrobi to, co chcesz.

Oto kilka przykładów z odpowiednimi ciągami poleceń programu startowego:

• Telegram (od wersji 0.7.10) ma -startintrayopcję:<path-to-Telegram>/Telegram -startintray
• Steam ma -silentopcję:/usr/bin/steam %U -silent
• Transmisja ma --minimizedopcję:/usr/bin/transmission-gtk --minimized

W Unity aplikacje te zaczynają być zminimalizowane jako ikony na górnym pasku menu, a nie jako ikony w programie uruchamiającym, chociaż normalna ikona uruchamiania będzie nadal wyświetlana po rozpoczęciu korzystania z aplikacji. Inne aplikacje mogą zachowywać się inaczej.

Wziąłem skrypty Jacoba i zmodyfikowałem je nieco, aby stały się bardziej uniwersalne.

#!/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)

Główne różnice to:

• Program ustawia identyfikator grupy (GID) dla procesu. W ten sposób można łatwo znaleźć wszystkie procesy potomne i ich okna
• Zamiast pętli while używana jest opcja xdotool --sync
• Skrypt umożliwia przekazywanie argumentów do programu

WAIT_TIME powinien być ustawiony na tyle, aby program mógł rozwidlać swoje procesy potomne. Na moim komputerze wystarczy na duże programy, takie jak Steam. W razie potrzeby zwiększ to.

Dodanie

xdotoolopcja windowunmapmoże działać funky z niektórymi aplikacjami i programami tacy (na przykład taca Linuksa mięty), więc oto alternatywna wersja skryptu dla tych wyjątków.

#!/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)

Jeśli program jest zamykany na pasku zadań, można faktycznie zamknąć okno programu podczas uruchamiania, zamiast go minimalizować. Jednym z przykładów takiego programu jest Viber. W takim przypadku można użyć następującego skryptu 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

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

Właśnie surfowałem i natknąłem się na to pytanie, więc zastanawiałem się, jaki jest twój system operacyjny? Jeśli chodzi o mnie, używam UBUNTU BUDGIE 18.04 LTS, więc w tym systemie operacyjnym jest to bardzo proste.

Po prostu przejdź do menu

Z menu przejdź do Ustawień pulpitu Budgie

i

Z ustawień pulpitu przejdź do Auto Start

Otrzymasz 2 opcje, od dodania „+”

1. Dodaj aplikację

2. Dodaj polecenie

Wybierając Dodaj aplikację, wszystkie aplikacje zostaną wyświetlone na liście, wybierz dowolną aplikację, która się uruchomi po uruchomieniu komputera, a także zostanie zminimalizowana.

Potrzebowałem programów zamkniętych do zasobnika, a nie zminimalizowanych, i wypróbowałem wszystkie skrypty tutaj opublikowane, te, które działały, działały tylko dla niektórych programów, a nie dla innych. Więc napisałem kod, który działa o wiele lepiej (prawie nie widać okna, tylko ikona na pasku, wygląda na natywny) i działa dla wszystkich programów, które wypróbowałem. Opiera się na modelu Jakuba. Za pomocą tego skryptu może być konieczne dodanie argumentu w zależności od programu (patrz poniżej), ale zawsze działało dla mnie z wieloma programami, powinno także działać ze Steam.

Stosowanie:

1. sudo apt-get install wmctrl xdotool
2. Zapisz skrypt, startup_closed.pynadając mu uprawnienia do wykonywania, a następnie uruchompython3 ./startup_closed.py -c <command to open program>
3. Jeśli ikona na pasku programu nie jest wyświetlana lub okno nie jest wyświetlane, musisz dodać jeden z tych argumentów: -splashlub -hidemetodą prób i błędów. Na przykład: python3 ./startup_closed.py -hide -c teamviewerlubpython3 ./startup_closed.py -splash -c slack
4. Jest więcej argumentów, ale prawdopodobnie ich nie potrzebujesz. Są też pełne szczegóły, kiedy i dlaczego potrzebne są argumenty w pomocy:./startup_closed.py --help

Scenariusz:

#!/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")

Przyszedłem z dość eleganckim rozwiązaniem, które opiera się wyłącznie na nim xdotool, i jest dość przydatne w aplikacjach, które nie mają argumentu „zminimalizuj start” , takich jak Telegram.

Jedynym minusem jest to, że rozwiązanie musi być ręcznie spreparowane dla każdej aplikacji, ale przy założeniu, że to nie jest problem (np. Jeśli chcesz automatycznie uruchomić określoną aplikację bez umożliwienia jej zanieczyszczenia ekranu po zalogowaniu) , jest to o wiele prostsze i proste .

Rzeczywiste przykłady

## 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 &

Rozwiązanie

Na pierwszy rzut oka możesz pomyśleć, że lepiej jest użyć PID procesu lub klasy, aby się z nim równać, jednak w rzeczywistości przynosi to efekt przeciwny do zamierzonego, ponieważ często otrzymasz wiele wyników dla tego samego PID. Przykładami są okna 0x0, które faktycznie czekają na powiadomienie, ikona paska zadań lub inne „ukryte” okno.

Rozwiązaniem jest wykonanie polecenia xdotool, które zawsze zwraca tylko jedno unikalne okno . W obu moich przykładach, które zostały wykonane przy użyciu --name, można jednak łączyć wiele selektorów z --all (np .: dopasować daną nazwę klasy + nazwę klasy + regex nazwy) . Zwykle dobry --nameregex załatwia sprawę.

Po searchstworzeniu warunków po prostu spawn wystąpienie xdotool (odłączone od powłoki) z --syncparametrem i warunkami, a następnie windowclose. Uruchom aplikację później:

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

Sprawdź xdotool search --helpwszystkie możliwości kombinacji, które możesz ustawić, aby móc kierować reklamy dokładnie na wybrane okno. Czasami staje się to trudne i musisz połączyć kilka warunków, ale kiedy skończysz, rzadko się nie powiedzie (chyba że aktualizacja zmieni aplikację i przerwie implementację, oczywiście).