¿Existe una opción de "no molestar" para ocultar temporalmente las notificaciones, como en las macbooks?

¿Existe el "modo No molestar" como lo es para el dispositivo OSX, donde puede decidir cuándo la notificación puede molestarlo o no ...

Acabo de instalar Chrome, y generalmente recibo spam por mensajes de texto grupales y otras notificaciones, lo que puede ser molesto cuando intento trabajar. En mi Macbook tengo la opción de activar "No molestar", que silencia toda forma de notificación. ¿Existe algo así para Ubuntu?

1. Actualización importante

Acabo de terminar una versión completamente reescrita del indicador (0.9.0). Las opciones ahora incluyen:

• suprimir solo notificaciones, que contienen cadenas específicas
• sonido de supresión (silenciamiento)
• registro de notificaciones perdidas
• corriendo en el inicio
• Recordando el último estado (suprimiendo o no) en la próxima ejecución

Además, muchas, muchas mejoras en la interfaz y el comportamiento.

La instalación no ha cambiado (ppa):

sudo apt-add-repository  ppa:vlijm/nonotifs
sudo apt-get update
sudo apt-get install nonotifs

2. Respuesta anterior (er)

Indicador para silenciar / mostrar notificaciones

Con el siguiente indicador, puede optar por desactivar temporalmente las notificaciones:

o mostrar notificaciones:

Cómo funciona

El truco es un comando simple, que se utiliza dbus-monitorpara interceptar las próximas notificaciones y detenerlas antes de que aparezcan.
El indicador es un "contenedor" fácil de usar para activarlo y desactivarlo.

Como instalar

Según ahora ( para Trusty, Vivid, Wily, Xenial ):

sudo apt-add-repository  ppa:vlijm/nonotifs
sudo apt-get update
sudo apt-get install nonotifs

Esto se instalará globalmente (incluido el iniciador). Se prefiere la instalación a través de ppa, ya que mantiene la última versión y se actualiza regularmente.
El indicador aparecerá en Dash como Sin notificaciones

Si realiza la instalación mediante el ppa, pero anteriormente se instaló manualmente desde abajo, ejecute rm ~/.local/share/applications/nonotif.desktopprimero para eliminar el .desktoparchivo local .

O manualmente:

La solución existe de una serie de elementos que simplemente necesita almacenar juntos en el mismo directorio.

1. Cree un directorio o carpeta (puede estar en cualquier parte de su directorio de inicio, por ejemplo)

2. El indicador: copie el script a continuación en un archivo vacío, guárdelo como nonotif_indicator.py:
   
   

   #!/usr/bin/env python3
   import os
   import signal
   import gi
   import subprocess
   gi.require_version('Gtk', '3.0')
   gi.require_version('AppIndicator3', '0.1')
   from gi.repository import Gtk, AppIndicator3
   
   currpath = os.path.dirname(os.path.realpath(__file__))
   proc = "nonotifs.sh"
   
   def run(path):
       try: 
           pid = subprocess.check_output(["pgrep", "-f", proc]).decode("utf-8").strip()
       except subprocess.CalledProcessError:
           subprocess.Popen(path+"/"+proc)
   
   def show():
       try:
           pid = subprocess.check_output(["pgrep", "-f", proc]).decode("utf-8").strip()
           subprocess.Popen(["pkill", "-P", pid])
       except subprocess.CalledProcessError:
           pass
   
   class Indicator():
       def __init__(self):
           self.app = 'nonotif'
           iconpath = currpath+"/grey.png"
           self.testindicator = AppIndicator3.Indicator.new(
               self.app, iconpath,
               AppIndicator3.IndicatorCategory.OTHER)
           self.testindicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)       
           self.testindicator.set_menu(self.create_menu())
   
       def create_menu(self):
           menu = Gtk.Menu()
           item_quit = Gtk.MenuItem('Quit')
           item_quit.connect('activate', self.stop)
           item_silent = Gtk.MenuItem("Don't disturb")
           item_silent.connect('activate', self.silent)
           item_show = Gtk.MenuItem("Show notifications")
           item_show.connect('activate', self.show)
           menu.append(item_quit)
           menu.append(item_silent)
           menu.append(item_show)
           menu.show_all()
           return menu
   
       def stop(self, source):
           Gtk.main_quit()
   
       def silent(self, source):
           self.testindicator.set_icon(currpath+"/red.png")
           run(currpath)
   
       def show(self, source):
           self.testindicator.set_icon(currpath+"/green.png")
           show()
   
   Indicator()
   signal.signal(signal.SIGINT, signal.SIG_DFL)
   Gtk.main()

3. El dbus-monitorguión; guárdelo (exactamente) como nonotifs.sh en el mismo directorio que el primer script:
   
   

   #!/bin/bash
   dbus-monitor "interface='org.freedesktop.Notifications'" | xargs -I '{}' pkill notify-osd

   Hacer este script ejecutable

4. Tres iconos; haga clic derecho en cada uno de ellos y guárdelos junto con los dos scripts como (exactamente):

   <- green.png

   <- red.png

   <- grey.png

5. Eso es. Ahora prueba-ejecuta el indicador con el comando:

   python3 /path/to/nonotif_indicator.py

   y cambiar notificaciones en / de

Lanzacohetes

En caso de que desee un lanzador con el indicador:

• Copie el icono a continuación, guárdelo como nonotificon.png:

  

• Copie el siguiente código en un archivo vacío:

  [Desktop Entry]
  Type=Application
  Name=No Notifications
  Exec=python3 /path/to/nonotif_indicator.py
  Icon=/path/to/nonotificon.png
  Type=Application

• Edita las líneas:

  Exec=python3 /path/to/nonotif_indicator.py

  y

  Icon=/path/to/nonotificon.png

  de acuerdo con las rutas reales y guarde el archivo como nonotif.desktopen~/.local/share/applications

Agregar el indicador a las aplicaciones de inicio

Puede agregar el indicador a Aplicaciones de inicio: Tablero> Aplicaciones de inicio> Agregar. Agrega el comando:

/bin/bash -c "sleep 15 && python3 /path/to/nonotif_indicator.py"

Introducción

El siguiente script permite silenciar cualquier notificación que aparezca en la pantalla. Hay dos opciones básicas -mpara silenciar y -uactivar silencio . Ambos se unen en un .desktoparchivo para servir como un iniciador.

Cuando -mse utiliza, la notificación osd enviará una notificación final antes de ser bloqueado. Si hay otra instancia de secuencia de comandos en ejecución, mostrará una ventana emergente gráfica que informará al usuario que la secuencia de comandos ya está haciendo su trabajo.

Cuando se llama con la -uopción, el script dejará de bloquear las notificaciones y lo confirmará mostrando una. Si no se está ejecutando ninguna instancia anterior del script, se notificará al usuario que nada está bloqueado en este momento.

Fuente de script

La fuente del script está disponible aquí. Para una versión más actualizada, siempre puede encontrarla en mi github . Puede instalar git con sudo apt-get install gity clonar todo el repositorio con git clone https://github.com/SergKolo/sergrep.gito usar

wget https://raw.githubusercontent.com/SergKolo/sergrep/master/notify-block.sh  && chmod +x notify-block.sh

para obtener solo el script en sí.

#!/usr/bin/env bash
#
###########################################################
# Author: Serg Kolo , contact: [email protected] 
# Date: May 10th 2016
# Purpose: Notification blocker for Ubuntu
# Written for: 
# Tested on:  Ubuntu 14.04 LTS
###########################################################
# Copyright: Serg Kolo ,2016 
#    
#     Permission to use, copy, modify, and distribute this software is hereby granted
#     without fee, provided that  the copyright notice above and this permission statement
#     appear in all copies.
#
#     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
#     THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
#     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
#     DEALINGS IN THE SOFTWARE.

ARGV0="$0"
ARGC=$#

mute_notifications()
{ 

  self=${ARGV0##*/}
  CHECK_PID_NUMS=$(pgrep -f  "$self -m" | wc -l )
  if [ "$CHECK_PID_NUMS" -gt 2 ]; then
     zenity --info --text "Notifications already disabled"
     exit 0
  else  
     killall notify-osd 2> /dev/null # ensure we have PID
     notify-send 'All notifications will be muted after this one' 
     sleep 1
     while true 
     do 
        PID=$(pgrep notify-osd)
        [  "x$PID" != "x" ]  && 
        kill -TERM $PID 
        sleep 0.25
     done
  fi
}

unmute()
{
  echo $0
  self=${0##*/}

  MUTE_PID=$(pgrep -f  "$self -m" ) #match self with -m option
  if [ "x$MUTE_PID" != "x"   ];then
     kill -TERM "$MUTE_PID" &&
     sleep 1 && # ensure the previous process exits
     notify-send "UNMUTED"
     exit 0
  else 
     notify-send "NOTIFICATIONS ALREADY UNMUTED"
     exit 0
  fi  
}

print_usage()
{
  cat > /dev/stderr <<EOF
  usage: notify-block.sh [-m|-u]
EOF
exit 1
}
main()
{
  [ $# -eq 0  ] && print_usage

  while getopts "mu" options
  do

     case ${options} in
          m) mute_notifications & ;;
          u) unmute ;;
          \?) print_usage ;;
     esac

  done
}
main "$@"

plantilla de acceso directo .desktop

Este es solo un ejemplo de lo que yo personalmente uso. Reemplace cada Exec=línea con la ruta adecuada para el script en su entorno. Por supuesto, Icon=también tendrá que cambiarlo. Preferiblemente, mantenga este archivo en su ~/.local/share/applicationscarpeta

[Desktop Entry]
Name=Notification Blocker
Comment=blocks any on-screen notifications
Terminal=false
Actions=Mute;Unmute
Type=Application
Exec=/home/xieerqi/sergrep/notify-block.sh -m
Icon=/home/xieerqi/Desktop/no-notif2.png

[Desktop Action Mute]
Name=Mute Notifications
Exec=/home/xieerqi/sergrep/notify-block.sh -m
Terminal=false

[Desktop Action Unmute]
Name=Unmute Notifications
Exec=/home/xieerqi/sergrep/notify-block.sh -u
Terminal=false

Capturas de pantalla

El archivo de acceso directo bloqueado en el iniciador

Notificación final antes de silenciar