Czy istnieje opcja „nie przeszkadzać”, aby tymczasowo ukryć powiadomienia, jak na Macbookach?

Czy istnieje tryb „Nie przeszkadzać”, tak jak ma to miejsce w przypadku urządzenia OSX, gdzie możesz zdecydować, kiedy powiadomienie może Ci przeszkadzać, czy nie…

Właśnie zainstalowałem Chrome i zazwyczaj spamują mnie teksty grupowe i inne powiadomienia, które mogą być denerwujące, gdy próbuję pracować. Na moim Macbooku mam opcję włączenia „Nie przeszkadzać”, która wycisza wszelkie formy powiadomień. Czy coś takiego istnieje dla Ubuntu?

1. Ważna aktualizacja

Właśnie skończyłem całkowicie przepisaną wersję wskaźnika (0.9.0). Opcje obejmują teraz:

• pomijanie tylko powiadomień zawierających określone ciągi znaków
• tłumienie (wyciszanie) dźwięku
• rejestrowanie nieodebranych powiadomień
• działa przy starcie
• zapamiętywanie ostatniego stanu (pomijanie lub nie) przy następnym uruchomieniu

Ponadto wiele ulepszeń interfejsu i zachowania.

Instalacja jest niezmieniona (ppa):

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

2. Stara (er) odpowiedź

Wskaźnik wyciszenia / pokazania powiadomień

Za pomocą poniższego wskaźnika możesz tymczasowo wyłączyć powiadomienia:

lub pokaż powiadomienia:

Jak to działa

Sztuczka to proste polecenie, dbus-monitorsłużące do przechwytywania nadchodzących powiadomień i zatrzymywania ich, zanim się pojawią.
Wskaźnik jest przyjaznym dla użytkownika „otokiem” do włączania i wyłączania.

Jak skonfigurować

Jak na razie ( dla Trusty, Vivid, Wily, Xenial ):

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

Zostanie to zainstalowane globalnie (w tym program uruchamiający). Preferowana jest instalacja przez ppa, ponieważ zachowuje najnowszą wersję i jest regularnie aktualizowana.
Wskaźnik pojawi się w Dash jako Brak powiadomień

Jeśli instalujesz przez PPA, ale wcześniej instalowałeś ręcznie od dołu, rm ~/.local/share/applications/nonotif.desktopnajpierw uruchom, aby usunąć .desktopplik lokalny .

Lub ręcznie:

Istnieje rozwiązanie wielu elementów, które po prostu trzeba przechowywać razem w jednym i tym samym katalogu.

1. Utwórz katalog lub folder (może znajdować się w dowolnym miejscu w katalogu domowym, np.)

2. Wskaźnik: skopiuj poniższy skrypt do pustego pliku, zapisz go jako 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. dbus-monitorSkrypt; zapisz (dokładnie) jak nonotifs.sh w jednym i tym samym katalogu co pierwszy skrypt:
   
   

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

   Spraw, aby ten skrypt był wykonywalny

4. Trzy ikony; kliknij prawym przyciskiem myszy każdy z nich i zapisz je razem z dwoma skryptami jako (dokładnie):

   <- green.png

   <- red.png

   <- grey.png

5. Otóż ​​to. Teraz uruchom test za pomocą polecenia:

   python3 /path/to/nonotif_indicator.py

   i włącz / wyłącz powiadomienia

Wyrzutnia

Jeśli chcesz wyrzutnię ze wskaźnikiem:

• Skopiuj ikonę poniżej i zapisz ją jako nonotificon.png:

  

• Skopiuj poniższy kod do pustego pliku:

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

• Edytuj linie:

  Exec=python3 /path/to/nonotif_indicator.py

  i

  Icon=/path/to/nonotificon.png

  zgodnie z rzeczywistymi ścieżkami i zapisz plik jak nonotif.desktopw~/.local/share/applications

Dodaj wskaźnik do aplikacji startowych

Możesz dodać wskaźnik do aplikacji startowych: Dash> Aplikacje startowe> Dodaj. Dodaj polecenie:

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

Wprowadzenie

Poniższy skrypt umożliwia wyciszenie wszelkich powiadomień pojawiających się na ekranie. Istnieją dwie podstawowe opcje -mwyciszania i -uwyłączania wyciszenia . Oba są połączone w .desktopplik, który ma służyć jako program uruchamiający.

Gdy -mjest używany, not-osd wyśle ​​ostateczne powiadomienie przed zablokowaniem. Jeśli uruchomiona jest inna instancja skryptu, wyświetli się graficzne wyskakujące okienko, które poinformuje użytkownika, że ​​skrypt już wykonuje swoją pracę.

Po wywołaniu z -uopcją skrypt przestanie blokować powiadomienia i potwierdzi to, pokazując jedno. Jeśli nie jest uruchomiona żadna poprzednia instancja skryptu, użytkownik zostanie powiadomiony, że w tej chwili nic nie jest blokowane.

Źródło skryptu

Źródło skryptu jest dostępne tutaj. Aby uzyskać bardziej aktualną wersję, zawsze możesz ją znaleźć na moim githubie . Możesz zainstalować git za pomocą sudo apt-get install giti sklonować całe repozytorium za pomocą git clone https://github.com/SergKolo/sergrep.gitlub użyć

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

aby uzyskać sam skrypt.

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

Szablon skrótu .desktop

To tylko przykład tego, czego osobiście używam. Zastąp każdą Exec=linię odpowiednią ścieżką do skryptu w swoim środowisku. Oczywiście Icon=trzeba będzie również zmienić. Najlepiej przechowuj ten plik w ~/.local/share/applicationsfolderze

[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

Zrzuty ekranu

Plik skrótu zablokowany w programie uruchamiającym

Ostateczne powiadomienie przed wyciszeniem