मैं स्टार्टअप पर एक कार्यक्रम कैसे चला सकता हूं, कम से कम?


19

मैं चाहता हूं कि टेलीग्राम चलाया जाए और मैंने इसे स्टार्टअप ऐप में शामिल किया है। मुद्दा यह है कि मुझे इसे कम से कम करने की आवश्यकता है। कोई आज्ञा?


टेलीग्राम शुरू करने के लिए क्या कमांड है और एप्लिकेशन शुरू होने के तुरंत बाद विंडो का नाम क्या है?
जैकब व्लिजम

मैंने जो कमांड का उपयोग किया है वह केवल ऐप का पथ है और विंडो का नाम टेलीग्राम डेस्कटॉप है
होसैन सोल्टानलू

हाय होसिएन, बस अगर आप खिड़की के शीर्षक के बजाय पिड का उपयोग करना पसंद कर सकते हैं, तो मेरे जवाब को संपादित किया।
याकूब Vlijm

@JacobVlijm धन्यवाद! यह बहुत कुशल और उपयोगी है! हालाँकि पहली विधि भिन्न रूप से चर विंडो नाम के मामलों में काम करती है। बहुत बढ़िया!
होसेन सोल्टानलो 5

1
@SumeetDeshmukh आप एक अविश्वसनीय रूप से अच्छे और उदार व्यक्ति हैं। वास्तव में!
याकूब Vlijm

जवाबों:


29

एक आवेदन शुरू करना कम से कम

एक आवेदन को न्यूनतम तरीके से शुरू करने में दो आदेश लगते हैं:

  • आवेदन शुरू
  • इसकी खिड़की को छोटा करें

इसलिए, कमांड या स्क्रिप्ट को "स्मार्ट" होने की आवश्यकता है; दूसरी कमांड वास्तव में दिखाई देने के लिए एप्लिकेशन विंडो के लिए इंतजार करना चाहिए।

एक आवेदन स्टार्टअप के लिए सामान्य समाधान कम से कम

नीचे दी गई स्क्रिप्ट ऐसा करती है और इसे कम से कम तरीके से किसी एप्लिकेशन को स्टार्टअप करने के लिए एक सामान्य समाधान के रूप में इस्तेमाल किया जा सकता है। इसे सिंटैक्स में चलाएं:

<script> <command_to_run_the_application> <window_name>

लिपी

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

कैसे इस्तेमाल करे

स्क्रिप्ट को दोनों की जरूरत है wmctrlऔर xdotool:

sudo apt-get install wmctrl xdotool

फिर:

  1. एक खाली फ़ाइल में स्क्रिप्ट की प्रतिलिपि बनाएँ, इसे सहेजें startup_minimizd.py
  2. परीक्षण- स्क्रिप्ट को (जैसे) geditकमांड से चलाएँ:

    python3 /path/to/startup_minimizd.py gedit gedit
    
  3. यदि सभी ठीक काम करते हैं, तो कमांड (आपके आवेदन के लिए) में जोड़ें Startup Applications

व्याख्या

  • स्क्रिप्ट एप्लिकेशन को शुरू करती है, जो कमांड आपने पहले तर्क के रूप में दी है
  • फिर स्क्रिप्ट विंडोज़ के लिए विंडो लिस्ट (उसकी मदद से wmctrl) आपके दूसरे तर्क के नाम पर जांचती है।
  • यदि विंडो दिखाई देती है, तो यह तुरंत xdotool एक अंतहीन लूप की मदद से कम से कम किया जाता है यदि खिड़की किसी कारण से प्रकट नहीं हो सकती है, तो स्क्रिप्ट दिखाई देने के लिए विंडो के लिए 30 सेकंड की समय सीमा का अभ्यास करती है।

ध्यान दें

यह उल्लेख करने की आवश्यकता नहीं है कि आप स्क्रिप्ट का उपयोग एक साथ कई अनुप्रयोगों के लिए कर सकते हैं, क्योंकि आप इसे स्क्रिप्ट के बाहर के तर्कों के साथ चलाते हैं।


संपादित करें

खिड़की को पहचान कर उसकी पिड

यदि विंडो शीर्षक अनिश्चित या परिवर्तनशील है, या विंडो के नाम में नाम की गड़बड़ी का खतरा है, तो उपयोग करने के pidलिए एक अधिक विश्वसनीय तरीका है।

नीचे दी गई स्क्रिप्ट एप्लिकेशन के पीड के उपयोग पर आधारित है, जैसा कि दोनों के आउटपुट में wmctrl -lpऔर ps -ef

सेटअप बहुत समान है, लेकिन इस संस्करण में विंडो शीर्षक की आवश्यकता नहीं है, इसलिए इसे चलाने का कमांड है:

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

पहली स्क्रिप्ट की तरह, इसे दोनों की जरूरत है wmctrlऔरxdotool

लिपी

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

दूसरी स्क्रिप्ट पर ध्यान दें

हालांकि सामान्य तौर पर दूसरे संस्करण को अधिक विश्वसनीय होना चाहिए, ऐसे मामलों में जब आवेदन एक आवरण स्क्रिप्ट द्वारा शुरू किया जाता है, कमांड का पिड आखिरकार उस एप्लिकेशन से अलग होगा जो कि कहा जाता है।

ऐसे मामलों में, मैं पहली स्क्रिप्ट का उपयोग करने की सलाह देता हूं।



EDIT2 स्टीम के लिए स्क्रिप्ट का एक विशिष्ट संस्करण है

जैसा कि एक टिप्पणी में अनुरोध किया गया है, एक संस्करण के नीचे, विशेष रूप से स्टैम को शुरू करने के लिए बनाया गया है।

स्टीम के लिए एक विशिष्ट संस्करण क्यों?

यह पता चलता है कि Steam"सामान्य" अनुप्रयोग से काफी भिन्न व्यवहार होता है:

  • यह पता चला Steamहै कि एक पिड नहीं चलता है , लेकिन तब (मेरे परीक्षण में) आठ से कम नहीं !
  • Steamकम से कम दो विंडो (एक स्प्लैश- जैसे विंडो) के साथ स्टार्ट अप पर चलता है , लेकिन कभी-कभी एक अतिरिक्त संदेश विंडो दिखाई देती है।
  • विंडोज की स्टीम है pid 0, जो स्क्रिप्ट में एक समस्या है जैसा कि था।
  • मुख्य विंडो बनने के बाद, विंडो को दूसरी बार या उसके बाद दूसरी बार उठाया जाता है, इसलिए एक एकल न्यूनतमकरण नहीं करेगा।

Steamस्क्रिप्ट के एक विशेष संस्करण के लिए यह असाधारण व्यवहार पूछता है, जिसे नीचे जोड़ा गया है। स्क्रिप्ट शुरू होती है Steam, और 12 सेकंड के दौरान, यह संबंधित सभी नई खिड़कियों पर नज़र रखता है WM_CLASS, अगर वे कम से कम हो तो जाँच करें। यदि नहीं, तो स्क्रिप्ट सुनिश्चित करती है कि वे होंगे।

मूल स्क्रिप्ट की तरह, यह एक की जरूरत है wmctrlऔर xdotoolस्थापित किया जाना है।

लिपी

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

इसके प्रयेाग के लिए

  • बस इसे एक खाली फ़ाइल में कॉपी करें, इसे इस रूप में सहेजें runsteam_minimized.py
  • इसे कमांड द्वारा चलाएं:

    python3 /path/to/runsteam_minimized.py
    

वाह, बहुत अच्छा! हालांकि मैं except:सिर्फ कोई नहीं लौटने के लिए पकड़ नहीं होगा । शायद बेहतर इसे विफल होने दें ताकि आप देखें कि क्या विफल हुआ; अन्यथा, यह किसी भी तरह के विभिन्न कारणों के लिए टूट सकता है और अनजाने में पारित हो जाएगा।
फेडोरक्वि

1
@fedorqui अच्छा एक, दो अपवादों की संभावना हो सकती है: subprocess.CalledProcesError (एक छोटी गाड़ी के परिणामस्वरूप wmctrl) और IndexError(सामान्य अपवाद) एक मिनट में संपादित हो जाएगा :)। उल्लेख के लिए धन्यवाद
याकूब Vlijm

@HosseinSoltanloo स्क्रिप्ट के साथ चलाने के लिए वास्तव में क्या कमांड है?
जैकब व्लिजम

@JacobVlijm स्क्रिप्ट अच्छी तरह से काम करती है लेकिन एक और समस्या है जिसे आप ठीक कर सकते हैं। जब भी मेरे पास अपठित संदेश होते हैं और मैं एप्लिकेशन खोलता हूं, तो विंडो का नाम कुछ "टेलीग्राम (2)" की तरह बदल जाता है क्योंकि दो अपठित संदेश हैं और इस तरह से स्क्रिप्ट नाम में परिवर्तन का काम नहीं करेगी।
होसैन सोल्टानलो

2
@JDHolland मुझे यकीन है कि इसे ठीक किया जा सकता है। अगले कुछ दिनों में कहीं और
देखेंगे

3

समस्या के सामान्य समाधान के रूप में user72216 और सर्गेई द्वारा दी गई लिपियों का होना अच्छा है, लेकिन कभी-कभी आपके द्वारा कम से कम स्टार्टअप के लिए किए गए एप्लिकेशन में पहले से ही एक स्विच होता है जो आपको चाहिए।

यहां संबंधित स्टार्टअप प्रोग्राम कमांड स्ट्रिंग्स के साथ कुछ उदाहरण दिए गए हैं:

  • तार (संस्करण 0.7.10 से) का -startintrayविकल्प है:<path-to-Telegram>/Telegram -startintray
  • स्टीम का -silentविकल्प है:/usr/bin/steam %U -silent
  • ट्रांसमिशन का --minimizedविकल्प है:/usr/bin/transmission-gtk --minimized

एकता में ये एप्लिकेशन लॉन्चर पर आइकन के बजाय शीर्ष मेनू बार में आइकन के रूप में कम से कम शुरू होते हैं, हालांकि सामान्य लॉन्च आइकन तब भी दिखाई देगा जब आप एप्लिकेशन का उपयोग करना शुरू करते हैं। अन्य एप्लिकेशन अलग तरीके से व्यवहार कर सकते हैं।


1

मैंने जैकब की स्क्रिप्ट ली और उन्हें और अधिक सार्वभौमिक बनाने के लिए थोड़ा संशोधित किया।

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

मुख्य अंतर हैं:

  • प्रोग्राम प्रक्रिया के लिए समूह ID (GID) सेट करता है। इस प्रकार, सभी बच्चे की प्रक्रिया और उनकी खिड़कियां आसानी से मिल सकती हैं
  • थोड़ी देर के लूप के बजाय xdotool --sync विकल्प का उपयोग किया जाता है
  • स्क्रिप्ट कार्यक्रम को तर्क देने की अनुमति देती है

WAIT_TIME को अपने बच्चे की प्रक्रियाओं को समझने के लिए प्रोग्राम को अनुमति देने के लिए पर्याप्त रूप से सेट किया जाना चाहिए। मेरे कंप्यूटर पर यह भाप जैसे बड़े कार्यक्रमों के लिए पर्याप्त है। जरूरत हो तो इसे बढ़ाएं।

इसके अलावा

xdotoolwindowunmapकुछ अनुप्रयोगों और ट्रे कार्यक्रमों (उदाहरण के लिए लिनक्स टकसाल की ट्रे) के साथ कायरता का विकल्प काम कर सकता है, इसलिए यहां उन अपवादों के लिए स्क्रिप्ट का एक वैकल्पिक संस्करण है।

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

मैंने आपकी पहली स्क्रिप्ट की कोशिश की। यह काम नहीं किया या पर्याप्त तेजी से कम नहीं किया। मैंने इसे बचाया startminimized। फिर मैं भागा startminimized gnome-calendar। कैलेंडर खुला और चालू रखें?
खुर्शीद आलम

1
आप चर को बढ़ाने की कोशिश कर सकते हैं WAIT_TIME। मैं कमजोर कंप्यूटर के लिए 40 सेकंड की देरी का उपयोग करता हूं। इसके अलावा, आप दूसरी स्क्रिप्ट आज़मा सकते हैं क्योंकि यह ऐप को कम करने के लिए एक अलग कमांड का उपयोग करता है।
सेर्गेई

1

यदि प्रोग्राम को ट्रे में बंद किया जा रहा है, तो कोई वास्तव में इसे कम करने के बजाय स्टार्टअप पर प्रोग्राम विंडो को बंद करना चाह सकता है। ऐसे कार्यक्रम का एक उदाहरण Viber है। इस मामले में एक निम्नलिखित स्क्रिप्ट का उपयोग कर सकता है 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

उपयोग: <path-to-script> <program-to-start>


1
आप ध्यान देना चाह सकते हैं कि xdotoolवेनलैंड के साथ प्रतिष्ठानों पर ठीक से काम नहीं करेगा।
विदेहोनथ

0

मैं बस सर्फ कर रहा था और इस सवाल पर आया था, इसलिए मैं सोच रहा था कि आपका ऑपरेटिंग सिस्टम क्या है? जैसा कि मेरे लिए मैं UBUNTU BUDGIE 18.04 LTS का उपयोग कर रहा हूं इसलिए इस ऑपरेटिंग सिस्टम में यह बहुत सरल है।

बस मेनू पर जाएं

मेनू से Budgie डेस्कटॉप सेटिंग्स पर जाएं

तथा

डेस्कटॉप सेटिंग से ऑटो स्टार्ट पर जाएं

यह आपको 2 विकल्प देगा, "+" ऐड से

1. एप्लिकेशन जोड़ें

2. कमांड जोड़ें

Add Application को सेलेक्ट करके सभी एप्लीकेशन को सूचीबद्ध किया जाएगा जिसे आप चाहते हैं किसी भी एप्लिकेशन का चयन करें और यह तब शुरू होगा जब आप अपना कंप्यूटर शुरू करेंगे और इसे कम से कम किया जाएगा।


0

मुझे ट्रे पर बंद किए गए कार्यक्रमों की आवश्यकता थी, कम से कम नहीं, और मैंने यहां पोस्ट की गई सभी लिपियों की कोशिश की है, जो काम करती हैं, केवल कुछ कार्यक्रमों के लिए काम किया है और दूसरों के लिए नहीं। इसलिए मैंने एक कोड किया है जो बहुत बेहतर तरीके से काम करता है (आप लगभग विंडो को दिखाई नहीं देते हैं, केवल ट्रे आइकन, यह मूल दिखता है) और उन सभी कार्यक्रमों के लिए काम करता है जो मैंने कोशिश की हैं। यह याकूब के एक पर आधारित है। इस स्क्रिप्ट के साथ आपको प्रोग्राम के आधार पर एक तर्क जोड़ने की आवश्यकता हो सकती है (नीचे देखें) लेकिन हमेशा मेरे लिए बहुत सारे कार्यक्रमों के साथ काम किया जो भाप के साथ भी काम करना चाहिए।

उपयोग:

  1. sudo apt-get install wmctrl xdotool
  2. स्क्रिप्ट को सहेजें के रूप में startup_closed.pyइसे निष्पादन अनुमति दें और फिर निष्पादित करेंpython3 ./startup_closed.py -c <command to open program>
  3. यदि प्रोग्राम ट्रे आइकन नहीं दिखाता है या विंडो नहीं दिखाता है, तो आपको इन तर्कों में से एक को जोड़ने की आवश्यकता है: -splashया -hide, परीक्षण और त्रुटि से। उदाहरण के लिए: python3 ./startup_closed.py -hide -c teamviewerयाpython3 ./startup_closed.py -splash -c slack
  4. अधिक तर्क हैं, लेकिन आपको शायद उनकी आवश्यकता नहीं है। मदद में तर्क कब और क्यों आवश्यक हैं, इसकी भी पूरी जानकारी है:./startup_closed.py --help

स्क्रिप्ट:

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

0

मैं एक बहुत ही सुंदर समाधान के साथ आया था जो विशेष रूप से निर्भर करता है xdotool, और यह उन अनुप्रयोगों के लिए काफी उपयोगी है जिनके पास "प्रारंभ न्यूनतम" नहीं है तर्क नहीं है, जैसे टेलीग्राम।

केवल नकारात्मक पक्ष यह है कि समाधान को प्रत्येक ऐप के लिए मैन्युअल रूप से तैयार किया जाना है, लेकिन यह मानते हुए कि यह कोई समस्या नहीं है (उदाहरण के लिए: यदि आप लॉग इन करने के बाद अपनी स्क्रीन को प्रदूषित करने की अनुमति के बिना एक निश्चित एप्लिकेशन को ऑटोस्टार्ट करना चाहते हैं) , यह बहुत सरल और सीधा है ।

वास्तविक उदाहरण

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

समाधान

पहली नज़र में, आप यह सोच सकते हैं कि प्रक्रिया 'PID या वर्ग का उपयोग करना बेहतर होगा, हालाँकि यह वास्तव में उल्टा है, क्योंकि आप अक्सर एक ही PID के लिए कई परिणाम प्राप्त करेंगे। उदाहरण एक 0x0 विंडो है जो वास्तव में एक अधिसूचना, एक सिस्ट्रे आइकन या किसी अन्य "छिपी" विंडो की प्रतीक्षा कर रहा है।

समाधान एक xdotool कमांड को क्राफ्ट कर रहा है जो हमेशा केवल एक अद्वितीय विंडो लौटाता है । मेरे दोनों उदाहरणों में --name, जिनका उपयोग करके किया गया था , हालाँकि आप कई चयनकर्ताओं को एक साथ जोड़ सकते हैं --all (उदाहरण के लिए: दिए गए classname + a class name + a name regex) से मेल खाते हैंआमतौर पर एक अच्छा --nameरेगेक्स ट्रिक करता है।

अपनी searchशर्तों को तैयार करने के बाद , बस पैरामीटर और आपकी शर्तों के साथ xdotool (शेल से अलग किया गया) का एक उदाहरण देखें --sync, उसके बाद windowclose। बाद में अपना ऐप चलाएं:

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

xdotool search --helpसंयोजनों की सभी संभावनाओं के लिए बाहर की जाँच करें जो आप चाहते हैं कि सटीक विंडो को लक्षित करने में सक्षम होने की व्यवस्था कर सकते हैं। कभी-कभी यह मुश्किल हो जाता है और आपको कई स्थितियों को संयोजित करना पड़ता है, लेकिन एक बार समाप्त होने के बाद, यह शायद ही कभी विफल होगा (जब तक कि कोई अपडेट एप्लिकेशन को नहीं बदलता है और आपके कार्यान्वयन को तोड़ देता है, निश्चित रूप से)।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.