¿Hay alguna manera de mostrar un icono solo mientras se ejecuta mi script?

Soy muy, muy nuevo en las secuencias de comandos. Aquí está el script simple (que funciona) que he escrito, que muestra una imagen cuando han pasado 5 minutos:

sleep 300 && firefox file:///home/tasks/fiveminutes.jpg

Aquí está mi pregunta: a veces no recuerdo si he iniciado el temporizador. ¿Hay alguna forma de agregar una indicación de texto o ícono (idealmente en la barra de tareas, pero en cualquier lugar sería genial) que aparece durante 5 minutos (desde el momento en que inicio el temporizador hasta el momento en que lo finalizo)?

Muchas gracias por las sugerencias.

Puede mostrar una notificación emergente cuando comienza el proceso. Simplemente cambie su guión a

notify-send "Your image will arrive" "after 5 minutes" && sleep 300 && firefox file:///home/tasks/fiveminutes.jpg

Puede establecer la duración de la burbuja de notificación con el -tparámetro (y el tiempo en milisegundos) con el notify-sendcomando, por ejemplo, para establecer la duración durante 5 minutos de uso

notify-send -t 300000 "heading" "text"

pero este parámetro puede ignorarse por completo dependiendo de su entorno de escritorio (vea esto ).

Es suficiente tener un script como este:

#!/usr/bin/env bash

while true
do
    if pgrep -f gedit > /dev/null
    then

       printf "\r%b" "\033[2K"
       printf "Script is running"
    else
       printf "\r%b" "\033[2K" 
       printf "Script is not running."
    fi
    sleep 0.25
done

Esta es una forma muy típica y de uso frecuente en los scripts de shell. Lo que esto hace es ejecutarse continuamente, y cada cuarto de segundo comprueba si su script se ejecuta a través de pgrep -f. if..filas declaraciones en los scripts de shell operan en el estado de salida de los comandos, por lo que pgrep -fdevolver un estado de salida exitoso significa que encontró el proceso de su script y se está ejecutando. De lo contrario, vamos a la declaración else.

En ambos casos imprimimos una línea de texto que le dice al usuario si se está ejecutando o no. También se agregó printf "\r%b" "\033[2K"para imprimir una secuencia de escape para borrar la línea (solo para una salida más limpia).

A partir de ahí, el cielo es el límite. Puede pasar ese texto a otro proceso en la terminal a través de una tubería o puede pasar la salida del script de monitoreo al indicador-sysmonitor , que permite mostrar información personalizada en el indicador. Se puede instalar a través de

sudo add-apt-repository ppa:fossfreedom/indicator-sysmonitor
sudo apt-get update
sudo apt-get install indicator-sysmonitor

Después de eso, simplemente configure el indicador para mostrar un comando personalizado que sería el script de supervisión. Puede encontrar un ejemplo de configuración de un comando personalizado aquí .

Por supuesto, uno podría escribir su propio indicador en Python, pero esto podría ser una exageración cuando ya hay una herramienta para eso.

Aquí está el iniciador de Python, basado en esta respuesta y una investigación adicional en Internet, que funciona bien en Ubuntu 16.04:

#!/usr/bin/env python3
import signal
import gi
import os
import subprocess
import sys
gi.require_version('Gtk', '3.0')
gi.require_version('AppIndicator3', '0.1')
from gi.repository import Gtk, AppIndicator3, GObject
import time
from threading import Thread

# Execute the script
script = os.path.basename(sys.argv[1])
subprocess.Popen(sys.argv[1:])
script_name = script.rsplit('/', 1)[-1]

class Indicator():
    def __init__(self):
        self.app = 'Script indicator'
        iconpath = "/usr/share/unity/icons/launcher_bfb.png"

        self.indicator = AppIndicator3.Indicator.new(
            self.app, iconpath,
            AppIndicator3.IndicatorCategory.OTHER)
        self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
        self.indicator.set_menu(self.create_menu())
        self.indicator.set_label("Script Indicator", self.app)
        # the thread:
        self.update = Thread(target=self.show_seconds)
        # daemonize the thread to make the indicator stopable
        self.update.setDaemon(True)
        self.update.start()

    def create_menu(self):
        menu = Gtk.Menu()
        # menu item 1
        item_quit = Gtk.MenuItem('Quit')
        item_quit.connect('activate', self.stop)
        menu.append(item_quit)

        menu.show_all()
        return menu

    def show_seconds(self):
        global script_name
        t = 0
        process = subprocess.call(['pgrep', script_name], stdout=subprocess.PIPE)
        while (process == 0):
            t += 1
            GObject.idle_add(
                self.indicator.set_label,
                script_name + ' ' + str(t) + 's', self.app,
                priority=GObject.PRIORITY_DEFAULT
                )
            time.sleep(1)
            process = subprocess.call(['pgrep', script_name], stdout=subprocess.PIPE)

        subprocess.call(['notify-send', script_name + ' ended in ' + str(t) + 's'])
        time.sleep(10)
        Gtk.main_quit()

    def stop(self, source):
        global script_name
        subprocess.call(['pkill', script_name], stdout=subprocess.PIPE)
        Gtk.main_quit()

Indicator()
# this is where we call GObject.threads_init()
GObject.threads_init()
signal.signal(signal.SIGINT, signal.SIG_DFL)
Gtk.main()

• Si ve alguna forma de mejorar el guión, no dude en editar la respuesta. No tengo mucha experiencia con Python.

Cree un archivo ejecutable y coloque las líneas anteriores como su contenido. Supongamos que se llama al archivo script-indicator.py. Dependiendo de sus necesidades y de la naturaleza de su script, puede usar este lanzador de una de las siguientes maneras:

./script-indicator.py /path/to/script.sh
./script-indicator.py /path/to/script.sh &
./script-indicator.py /path/to/script.sh > out.log &
./script-indicator.py /path/to/script.sh > /dev/null &

• ¿Dónde script.shestá el que quieres indicar?

Captura de pantalla realizada justo cuando script.shfinaliza:

• Haga clic en la imagen para ver una demostración animada.

Alternativamente, puede colocar el script /usr/local/binpara que sea accesible como sistema de comando de shell en todo el sistema. Puede descargarlo desde este dedicado GitHub Gist:

sudo wget -qO /usr/local/bin/script-indicator https://gist.githubusercontent.com/pa4080/4e498881035e2b5062278b8c52252dc1/raw/c828e1becc8fdf49bf9237c32b6524b016948fe8/script-indicator.py
sudo chmod +x /usr/local/bin/script-indicator

Lo probé con la siguiente sintaxis:

script-indicator /path/to/script.sh
script-indicator /path/to/script.sh &
script-indicator /path/to/script.sh > output.log
script-indicator /path/to/script.sh > output.log &
script-indicator /path/to/script.sh > /dev/null
script-indicator /path/to/script.sh > /dev/null &
nohup script-indicator /path/to/script.sh >/dev/null 2>&1 &
# etc...

Con osd_cat

Puede usar osd_catdesde el xosd-bin paquete, por ejemplo:

<<<"runs" osd_cat -d5 -i20 -o50 -f"-*-*-*-*-*-*-100-*-*-*-*-*-*-*" && firefox

Esto muestra "carreras" con tamaño de fuente 100durante 5segundos en la posición 20,50en la pantalla y comienza firefoxcuando está listo; no es necesario sleepcon este enfoque. Puede usar xfontselpara obtener el Descriptor de fuente lógica X (esta -*-*-…cosa rara ) para la -fopción, por ejemplo, si desea usar una fuente diferente. Lea man osd_catpara más opciones.

Con yad

Puede usar yad lo siguiente:

yad --title=runs --text="it’s running!" --timeout=5 --button=Fire:1 --button=Abort:0 || firefox

Esto tiene la ventaja de que puede abortar el comando o ejecutarlo inmediatamente, si no hace nada, se cerrará después de 5segundos en este ejemplo.

Puede tomar esta secuencia de comandos que ya funcionamulti-timer y eliminar la mayor parte para obtener un temporizador de cuenta regresiva genérico:

Utiliza lo mismo indicator-sysmonitordescrito en la respuesta de Serge.

La parte Systray Brightness: 2344también se muestra con el mismo script.

Si eliminar partes innecesarias del código bash es demasiado difícil para los nuevos usuarios, me complacería publicar un script aquí llamado show-sleepcon la funcionalidad limitada necesaria. Simplemente publique un comentario a continuación.