Existe uma opção "não perturbe" para ocultar temporariamente as notificações, como nos macbooks?

Existe o modo "Não perturbe", como ocorre no dispositivo OSX, onde você pode decidir quando a notificação pode incomodá-lo ou não.

Acabei de instalar o chrome, e geralmente recebo spam por textos em grupo e outras notificações, o que pode ser irritante quando tento trabalhar. No meu macbook, tenho a opção de ativar "Não perturbe", que silencia todas as formas de observação. Existe algo assim para o Ubuntu?

1. Major update

Acabei de terminar uma versão completamente reescrita do indicador (0.9.0). As opções agora incluem:

• suprimindo apenas notificações, contendo seqüências específicas
• suprimir (silenciar) o som
• registrar notificações perdidas
• executando na inicialização
• lembrando o último estado (suprimindo ou não) na próxima execução

Além disso, muitas, muitas melhorias na interface e no comportamento.

A instalação permanece inalterada (ppa):

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

2. Resposta antiga

Indicador para silenciar / mostrar notificações

Com o indicador abaixo, você pode optar por desativar temporariamente as notificações:

ou mostrar notificações:

Como funciona

O truque é um comando simples, usado dbus-monitorpara interceptar as próximas notificações e pará-las antes que elas apareçam.
O indicador é um "invólucro" fácil de usar para ativar e desativar.

Como configurar

Conforme agora ( para Trusty, Vivid, Wily, Xenial ):

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

Isso será instalado globalmente (incluindo o iniciador). A instalação via ppa é preferida, pois mantém a versão mais recente e é atualizada regularmente.
O indicador aparecerá no Dash como NoNotifications

Se você instalar pelo ppa, mas anteriormente instalado manualmente a partir de baixo, execute rm ~/.local/share/applications/nonotif.desktopprimeiro para remover o .desktoparquivo local .

Ou manualmente:

A solução existe em vários itens que você simplesmente precisa armazenar juntos em um e no mesmo diretório.

1. Crie um diretório ou pasta (pode estar em qualquer lugar do seu diretório pessoal, por exemplo)

2. O indicador: Copie o script abaixo em um arquivo vazio, salve-o 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. O dbus-monitorscript; salve-o (exatamente) como nonotifs.sh em um e no mesmo diretório que o primeiro script:
   
   

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

   Tornar este script executável

4. Três ícones; clique com o botão direito do mouse em cada uma delas e salve-as juntamente com os dois scripts, como (exatamente):

   <- green.png

   <- red.png

   <- grey.png

5. É isso aí. Agora, execute o indicador com o comando:

   python3 /path/to/nonotif_indicator.py

   e ativar / desativar as notificações

Launcher

Caso você queira um lançador com o indicador:

• Copie o ícone abaixo, salve-o como nonotificon.png:

  

• Copie o código abaixo em um arquivo vazio:

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

• Edite as linhas:

  Exec=python3 /path/to/nonotif_indicator.py

  e

  Icon=/path/to/nonotificon.png

  de acordo com os caminhos reais e salve o arquivo como nonotif.desktopem~/.local/share/applications

Adicione o indicador aos aplicativos de inicialização

Você pode adicionar o indicador a Aplicativos de inicialização: Dash> Aplicativos de inicialização> Adicionar. Adicione o comando:

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

Introdução

O script abaixo permite que as notificações sejam desativadas na tela. Existem duas opções básicas -mpara ativar e -udesativar o som. Ambos são reunidos em um.desktop arquivo para servir como iniciador.

Quando -m usado, o notify-osd envia uma notificação final antes de ser bloqueado. Se houver outra instância do script em execução, ele mostrará um pop-up gráfico que informará ao usuário que o script já está fazendo seu trabalho.

Quando chamado com -u opção, o script para de bloquear as notificações e confirma isso mostrando uma. Se nenhuma instância anterior do script estiver em execução, o usuário será notificado de que nada está bloqueado no momento.

Origem do Script

A fonte do script está disponível aqui. Para uma versão mais atualizada, você sempre pode encontrá-la no meu github . Você pode instalar o git sudo apt-get install gite clonar todo o repositório git clone https://github.com/SergKolo/sergrep.gitou usar

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

para obter apenas o próprio script.

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

Modelo de atalho .desktop

Este é apenas um exemplo do que eu pessoalmente uso. Substitua cada Exec=linha pelo caminho apropriado para o script em seu ambiente. Claro que você Icon=também terá que mudar. De preferência, mantenha esse arquivo na sua ~/.local/share/applicationspasta

[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

Screenshots

O arquivo de atalho bloqueado para o iniciador

Notificação final antes de silenciar