मैं चाहता हूं कि टेलीग्राम चलाया जाए और मैंने इसे स्टार्टअप ऐप में शामिल किया है। मुद्दा यह है कि मुझे इसे कम से कम करने की आवश्यकता है। कोई आज्ञा?
मैं चाहता हूं कि टेलीग्राम चलाया जाए और मैंने इसे स्टार्टअप ऐप में शामिल किया है। मुद्दा यह है कि मुझे इसे कम से कम करने की आवश्यकता है। कोई आज्ञा?
जवाबों:
एक आवेदन को न्यूनतम तरीके से शुरू करने में दो आदेश लगते हैं:
इसलिए, कमांड या स्क्रिप्ट को "स्मार्ट" होने की आवश्यकता है; दूसरी कमांड वास्तव में दिखाई देने के लिए एप्लिकेशन विंडो के लिए इंतजार करना चाहिए।
नीचे दी गई स्क्रिप्ट ऐसा करती है और इसे कम से कम तरीके से किसी एप्लिकेशन को स्टार्टअप करने के लिए एक सामान्य समाधान के रूप में इस्तेमाल किया जा सकता है। इसे सिंटैक्स में चलाएं:
<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
फिर:
startup_minimizd.py
परीक्षण- स्क्रिप्ट को (जैसे) gedit
कमांड से चलाएँ:
python3 /path/to/startup_minimizd.py gedit gedit
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)
हालांकि सामान्य तौर पर दूसरे संस्करण को अधिक विश्वसनीय होना चाहिए, ऐसे मामलों में जब आवेदन एक आवरण स्क्रिप्ट द्वारा शुरू किया जाता है, कमांड का पिड आखिरकार उस एप्लिकेशन से अलग होगा जो कि कहा जाता है।
ऐसे मामलों में, मैं पहली स्क्रिप्ट का उपयोग करने की सलाह देता हूं।
जैसा कि एक टिप्पणी में अनुरोध किया गया है, एक संस्करण के नीचे, विशेष रूप से स्टैम को शुरू करने के लिए बनाया गया है।
यह पता चलता है कि 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:
सिर्फ कोई नहीं लौटने के लिए पकड़ नहीं होगा । शायद बेहतर इसे विफल होने दें ताकि आप देखें कि क्या विफल हुआ; अन्यथा, यह किसी भी तरह के विभिन्न कारणों के लिए टूट सकता है और अनजाने में पारित हो जाएगा।
subprocess.CalledProcesError
(एक छोटी गाड़ी के परिणामस्वरूप wmctrl
) और IndexError
(सामान्य अपवाद) एक मिनट में संपादित हो जाएगा :)। उल्लेख के लिए धन्यवाद
समस्या के सामान्य समाधान के रूप में user72216 और सर्गेई द्वारा दी गई लिपियों का होना अच्छा है, लेकिन कभी-कभी आपके द्वारा कम से कम स्टार्टअप के लिए किए गए एप्लिकेशन में पहले से ही एक स्विच होता है जो आपको चाहिए।
यहां संबंधित स्टार्टअप प्रोग्राम कमांड स्ट्रिंग्स के साथ कुछ उदाहरण दिए गए हैं:
-startintray
विकल्प है:<path-to-Telegram>/Telegram -startintray
-silent
विकल्प है:/usr/bin/steam %U -silent
--minimized
विकल्प है:/usr/bin/transmission-gtk --minimized
एकता में ये एप्लिकेशन लॉन्चर पर आइकन के बजाय शीर्ष मेनू बार में आइकन के रूप में कम से कम शुरू होते हैं, हालांकि सामान्य लॉन्च आइकन तब भी दिखाई देगा जब आप एप्लिकेशन का उपयोग करना शुरू करते हैं। अन्य एप्लिकेशन अलग तरीके से व्यवहार कर सकते हैं।
मैंने जैकब की स्क्रिप्ट ली और उन्हें और अधिक सार्वभौमिक बनाने के लिए थोड़ा संशोधित किया।
#!/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)
मुख्य अंतर हैं:
WAIT_TIME को अपने बच्चे की प्रक्रियाओं को समझने के लिए प्रोग्राम को अनुमति देने के लिए पर्याप्त रूप से सेट किया जाना चाहिए। मेरे कंप्यूटर पर यह भाप जैसे बड़े कार्यक्रमों के लिए पर्याप्त है। जरूरत हो तो इसे बढ़ाएं।
इसके अलावा
xdotool
windowunmap
कुछ अनुप्रयोगों और ट्रे कार्यक्रमों (उदाहरण के लिए लिनक्स टकसाल की ट्रे) के साथ कायरता का विकल्प काम कर सकता है, इसलिए यहां उन अपवादों के लिए स्क्रिप्ट का एक वैकल्पिक संस्करण है।
#!/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
। कैलेंडर खुला और चालू रखें?
WAIT_TIME
। मैं कमजोर कंप्यूटर के लिए 40 सेकंड की देरी का उपयोग करता हूं। इसके अलावा, आप दूसरी स्क्रिप्ट आज़मा सकते हैं क्योंकि यह ऐप को कम करने के लिए एक अलग कमांड का उपयोग करता है।
यदि प्रोग्राम को ट्रे में बंद किया जा रहा है, तो कोई वास्तव में इसे कम करने के बजाय स्टार्टअप पर प्रोग्राम विंडो को बंद करना चाह सकता है। ऐसे कार्यक्रम का एक उदाहरण 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>
xdotool
वेनलैंड के साथ प्रतिष्ठानों पर ठीक से काम नहीं करेगा।
मैं बस सर्फ कर रहा था और इस सवाल पर आया था, इसलिए मैं सोच रहा था कि आपका ऑपरेटिंग सिस्टम क्या है? जैसा कि मेरे लिए मैं UBUNTU BUDGIE 18.04 LTS का उपयोग कर रहा हूं इसलिए इस ऑपरेटिंग सिस्टम में यह बहुत सरल है।
बस मेनू पर जाएं
मेनू से Budgie डेस्कटॉप सेटिंग्स पर जाएं
तथा
डेस्कटॉप सेटिंग से ऑटो स्टार्ट पर जाएं
यह आपको 2 विकल्प देगा, "+" ऐड से
1. एप्लिकेशन जोड़ें
2. कमांड जोड़ें
Add Application को सेलेक्ट करके सभी एप्लीकेशन को सूचीबद्ध किया जाएगा जिसे आप चाहते हैं किसी भी एप्लिकेशन का चयन करें और यह तब शुरू होगा जब आप अपना कंप्यूटर शुरू करेंगे और इसे कम से कम किया जाएगा।
मुझे ट्रे पर बंद किए गए कार्यक्रमों की आवश्यकता थी, कम से कम नहीं, और मैंने यहां पोस्ट की गई सभी लिपियों की कोशिश की है, जो काम करती हैं, केवल कुछ कार्यक्रमों के लिए काम किया है और दूसरों के लिए नहीं। इसलिए मैंने एक कोड किया है जो बहुत बेहतर तरीके से काम करता है (आप लगभग विंडो को दिखाई नहीं देते हैं, केवल ट्रे आइकन, यह मूल दिखता है) और उन सभी कार्यक्रमों के लिए काम करता है जो मैंने कोशिश की हैं। यह याकूब के एक पर आधारित है। इस स्क्रिप्ट के साथ आपको प्रोग्राम के आधार पर एक तर्क जोड़ने की आवश्यकता हो सकती है (नीचे देखें) लेकिन हमेशा मेरे लिए बहुत सारे कार्यक्रमों के साथ काम किया जो भाप के साथ भी काम करना चाहिए।
उपयोग:
sudo apt-get install wmctrl xdotool
startup_closed.py
इसे निष्पादन अनुमति दें और फिर निष्पादित करेंpython3 ./startup_closed.py -c <command to open program>
-splash
या -hide
, परीक्षण और त्रुटि से। उदाहरण के लिए: python3 ./startup_closed.py -hide -c teamviewer
याpython3 ./startup_closed.py -splash -c slack
./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")
मैं एक बहुत ही सुंदर समाधान के साथ आया था जो विशेष रूप से निर्भर करता है 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
संयोजनों की सभी संभावनाओं के लिए बाहर की जाँच करें जो आप चाहते हैं कि सटीक विंडो को लक्षित करने में सक्षम होने की व्यवस्था कर सकते हैं। कभी-कभी यह मुश्किल हो जाता है और आपको कई स्थितियों को संयोजित करना पड़ता है, लेकिन एक बार समाप्त होने के बाद, यह शायद ही कभी विफल होगा (जब तक कि कोई अपडेट एप्लिकेशन को नहीं बदलता है और आपके कार्यान्वयन को तोड़ देता है, निश्चित रूप से)।