# mod/commun.py
import cfg
import inc.infos as infos
import inc.mpc as mpc
ESPACE_JUKEBOX_MINIMAL_REQUIS_MO = 2000 # 2000 Mo, soit 2 Go
ESPACE_JUKEBOX_AVERTISSEMENT_MO = 4000 # 4000 Mo, soit 4 Go
def aideVisuel1 (menu_appareil = None, display1 = 'yes'):
aideVisuel(menu_appareil, "module", display1)
def aideVisuel2 (menu_appareil = None, display1 = 'yes'):
aideVisuel(menu_appareil, "commun", display1)
def aideVisuel (menu_appareil, partie, display1 = None):
""" On affiche le menu des touches possibles
quand on change de module
affiche
"""
curr_modul = infos.ini_get("py_current_module", "juk")
if menu_appareil is None:
menu_appareil = curr_modul
menus = cfg.dic_menus
menu_separes = [menus.get(menu_appareil), menus.get("commun")]
menu_titres = ["_Module_" + curr_modul, "Commun"]
if partie == "module":
i = 0
else: # partie commune
i = 1
menu = menu_separes[i]
titre = menu_titres[i]
def nouveau_tri(clefs):
# trier les clefs dans cet ordre :
# 1. les touches simples (1, 2, 3, ...)
# 2. les touches complexes (11, 22, ...)
clefs.sort()
clefs_simples = []
clefs_doubles = []
clefs_slash_etoile = []
clefs_autres = []
clefs_DEV = []
for i in clefs:
if i in [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]:
clefs_simples.append(i)
elif i in [ "00", "11", "22", "33", "44", "55", "66", "77", "88", "99"]:
clefs_doubles.append(i)
elif i in [ "/", "//", "/*", "*", "**", "*/" ]:
clefs_slash_etoile.append(i)
elif i in [ "...", ".0", "0.", "--", "---", "----", "++", "+++", "++++", "-+", "778", "779", "34", "*9" ]:
clefs_DEV.append(i)
else:
clefs_autres.append(i) # /, //, /*, etc...
clefs = clefs_simples + clefs_doubles + \
clefs_slash_etoile + clefs_autres
# clefs = clefs_simples + [ "---------- Touches doubles " ] + \
# clefs_doubles + [ "---------- Touches autres" ] + \
# clefs_slash_etoile + [ "---------- Touches / et *" ] + \
# clefs_autres
return clefs, clefs_DEV
clefs, clefs_DEV = nouveau_tri(list(menu.keys()))
infos.m_g("")
infos.m_g("- " * 10 + titre + " -" * 10)
if not display1 is None:
for i in clefs:
# pad string avec rjust
if i.startswith("----------"):
infos.m_g(i)
else:
infos.m_g(str(i).rjust(4) + ' ' + menu.get(i)[1])
infos.m_g("")
return menu, clefs, clefs_DEV # pour aide_rapide_NEW()
def clear_screen ():
""" vider l'écran """
mpc.sub_proc("clear")
def date_heure_fr(type_demande = None):
""" date heure en français
samedi 29 février 2020, 10 heures 03
"""
# https://www.developpez.net/forums/d709021/autres-langages/python/general-python/date-francais/
import locale
locale.setlocale(locale.LC_TIME,'')
# https://www.programiz.com/python-programming/datetime/strftime
from time import localtime, strftime
if type_demande is None:
type_demande = "jour_heure"
else:
type_demande = "heure"
if type_demande == "jour_heure":
auj = strftime("%A %d %B %Y, %H heures %M", localtime())
else:
auj = strftime("%H heures %M", localtime())
auj = auj.replace("heures 00", "heures pile")
auj = auj.replace("heures 01", "heures une")
return auj
def detente ():
infos.m_g("juk Détente")
def disHeure ():
infos.pdrNew("Nous sommes le " + date_heure_fr())
def entier(nombre):
""" """
s = str(nombre)
# 19,7
if s.find("."):
t = s.split(".")
return t[0]
else:
return nombre
def enonce_touches():
""" manuel utilisateur du module en cours """
msg = "Voici les touches de commande du module actuel" + \
"Voici les touches de commande du module actuel" + \
"Appuyez sur 1 pour écouter les touches communes"
infos.pdrNew(msg)
def eteindre(confirmer = ""):
""" éteindre l'appareil maintenant
"""
mpc.ferme_ton_clapet()
if confirmer == "":
import time
code_confirm = "9" + str(time.time())[:2] # nombre au hasard
msg = "Pour vraiment éteindre l'appareil électriquement, " + \
"appuyez sur " + code_confirm + " puis Entrée, " + \
"ou Entrée simplement pour annuler"
infos.pdrNew(msg)
touche = input()
if touche == code_confirm:
msg = "Extinction des feux"
infos.pdrNew(msg)
cmd = "sudo shutdown -h now"
mpc.sub_proc(cmd)
else: # appeler la fonction avec argu non vide pour éteindre immédiatement
# à utiliser pour les arrêts programmés
cmd = "sudo shutdown -h now"
mpc.sub_proc(cmd)
def fake_apprentissage():
""" touches 12 interceptées dans inputkiz """
pass
def faire_pause(pause_en_sec, display = False):
""" temporiser un peu """
import time
if display == True:
# print ("Pause de " + str(pause_en_sec) + "s")
# print ("Start : %s, %s" % (time.ctime(), time.time()))
time.sleep( int(pause_en_sec) )
# print ("End : %s, %s" % (time.ctime(), time.time()))
else:
time.sleep( int(pause_en_sec) )
def file_stripped(fichier):
""" renvoie un tableau de lignes stripped
"""
with open(fichier, "r") as f:
lignes = f.readlines()
u_stripped = []
for ligne in lignes:
u_stripped.append(ligne.strip())
return u_stripped
def dir_exists(dossier):
""" teste existence d'un fichier/dossier """
# https://stackabuse.com/python-check-if-a-file-or-directory-exists/
from os import path
return path.isdir(dossier)
def du(dossier):
""" renvoie un int
taille totale du dossier en méga octets
(sous-dossiers compris)
"""
cmd = "du -s " + dossier + " | awk '{print $1}'"
kilo_octets_occupes = mpc.sub_proc(cmd)
mega_octets_occupes = int(int(kilo_octets_occupes)/1000)
return mega_octets_occupes
def espace(quoi, dossier = None):
""" quoi prend une des deux valeurs :
"suffisant" : renvoie true/false
"libre" : "espace libre, 3200 méga octets"
"""
def volume_libre(dossier = None):
""" renvoie une chaîne du type '1556 Mo restants' """
espace_libre = ("df " + dossier + " | tail -1 | awk '{print $4}'")
kilo_octets = int(mpc.sub_proc(espace_libre))
mega_octets = str(int(kilo_octets/1024))
msg = "espace libre, {} méga octets".format(mega_octets)
return msg
def volume_suffisant(dossier = None):
""" renvoie un booléen indiquant si espace suffisant
pour fonctionnement du module """
espace_libre = "df " + dossier + " | tail -1 | awk '{print $4}'"
kilo_octets = int(mpc.sub_proc(espace_libre))
# minimum requis : 1 Go d'espace libre sur clé usb
# NB : peut être insuffisant pour un gros livre
# refaire un contrôle avant téléchargement dans dl_media(), ou autre
if kilo_octets < ESPACE_JUKEBOX_MINIMAL_REQUIS_MO * 1000:
return False, "espace restant inférieur à {} méga octets".format(ESPACE_JUKEBOX_MINIMAL_REQUIS_MO)
return True, "espace suffisant"
if dossier is None:
dossier = "/m"
if quoi == "libre":
return volume_libre(dossier)
elif quoi == "suffisant":
return volume_suffisant(dossier)
else:
infos.pdrNew("Mauvais paramètre donné à la fonction espace")
def file_exists(fichier):
""" teste existence d'un fichier/dossier """
from os import path
return path.isfile(fichier)
def file_size_zero(fichier):
""" teste si fichier taille nulle, sans vérifier son existence """
# https://stackoverflow.com/questions/2104080/how-to-check-file-size-in-python
import os
return os.path.getsize(fichier) == 0
def files_recurse(src_dir):
""" renvoie une liste triée de (noms complets de )
fichiers d'un dossier, avec récurrence """
import os
res_list = []
for root, dirs, files in os.walk(src_dir, topdown = False):
for name in files:
res_list.append(os.path.join(root, name))
res_list.sort()
return res_list
def files_simple(src_dir):
""" renvoie une liste triée de (noms complets de )
fichiers d'un dossier, sans récurrence """
import os
res_list = []
for f in os.scandir(src_dir):
if f.is_file():
res_list.append(src_dir + "/" + f.name)
res_list.sort()
return res_list
def files_audio_simple(src_dir):
""" renvoie une liste triée de (noms complets de )
fichiers audio d'un dossier, sans récurrence """
import os
res_list = []
for f in os.scandir(src_dir):
if f.is_file():
f_low = f.name.lower()
if (
(f_low.endswith(".mp3")) or
(f_low.endswith(".m4a")) or
(f_low.endswith(".ogg")) or
(f_low.endswith(".wav")) or
(f_low.endswith(".wma"))
):
res_list.append(src_dir + "/" + f.name)
res_list.sort()
return res_list
def folders_recurse(src_dir):
""" renvoie une liste triée de tous les sous-dossiers
du dossier path, en nom complet (pas relatif) """
# https://www.tutorialspoint.com/python3/os_walk.htm
# https://stackabuse.com/python-list-files-in-a-directory/
import os
res_list = []
for root, dirs, files in os.walk(src_dir, topdown = False):
for name in dirs:
res_list.append(os.path.join(root, name))
res_list.sort()
return res_list
def folders_simple(src_dir):
""" renvoie une liste triée de (noms complets de )
dossiers d'un dossier, sans récurrence """
import os
res_list = []
for f in os.scandir(src_dir):
if f.is_dir():
res_list.append(src_dir + "/" + f.name)
res_list.sort()
return res_list
def folders_simple_nom_seul(src_dir):
""" renvoie une liste triée de (noms complets de )
dossiers d'un dossier, sans récurrence """
# ~ print("folders_simple_nom_seul " + src_dir)
import os
res_list = []
for f in os.scandir(src_dir):
if f.is_dir():
# ~ print("f.name = " + f.name)
res_list.append(f.name)
res_list.sort()
return res_list
def juk_menu_special11():
""" menu spécial juk """
retour = menu_vocal("juk_special11", "jukebox")
def m_is_mounted():
""" vérifie que le dossier /dev/sda1 est bien monté sur /m
"""
cmd_output = "/tmp/m_is_mounted.txt"
cmd = "mount | grep /dev/sda1 | grep /m > " + cmd_output
r = mpc.sub_proc(cmd)
with open(cmd_output, "r") as f:
ligne_montage = f.readlines()[0]
infos.m_g("ligne montage = " + ligne_montage)
# /dev/sda1 on /m type vfat (rw,relatime,fmask=0000,dmask=0000,allow_utime=0022,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
if ligne_montage.startswith("/dev/sda1 on /m "):
infos.m_g("/dev/sda1 est bien monté sur /m")
return True
else:
infos.m_g("ERR : /dev/sda1 n'est pas monté sur /m")
return False
def menu_vocal(mnu, titre, explication = None):
""" menu générique
lancer des commandes en entendant la description
de la commande sélectionnée
appuyer sur Entrée pour lancer la commande entendue
et quitter le menu spécial """
le_menu = cfg.dic_menus[mnu]
infos.m_g("menu vocal " + titre)
mpc.ferme_ton_clapet()
TOUCHES = 0
COMMANDE = 1
DESC = 2
# 1. créer la liste des commandes
cmdz = [] # cmdz = commandes
cmd_desc = []
cles = list(le_menu.keys())
cles.sort()
for cle in cles:
commande, desc = le_menu[cle]
cmdz.append([cle, commande, desc])
cmd_desc.append(desc)
# 2. explication fonctionnement du menu
mpc.pause()
if explication is None:
# explication = \
# "bienvenue dans le menu vocal, " + \
# "utilisez les touches 1 à {0} pour écouter " + \
# "une des {0} actions disponibles, " + \
# "Pressez ensuite Entrée pour la lancer, " + \
# "ou bien zéro pour sortir de ce menu"
explication = \
"bienvenue dans le menu vocal, " + \
"utilisez les touches 1 à {0} pour écouter " + \
"les actions proposées. " + \
"Pressez ensuite Entrée pour la lancer, " + \
"ou une autre touche si l'action ne vous convient pas. " + \
"Ou enfin zéro pour sortir de ce menu"
msg1 = "Menu " + titre
msg2 = msg1 + ". " + explication.format(len(cmdz))
infos.pdrNew([msg1, msg2])
idx = 0
for c in cmdz:
if c[TOUCHES] == "E":
c[TOUCHES] = "Entrée"
elif c[TOUCHES] == "EE":
c[TOUCHES] = "Deux fois Entrée"
idx += 1
# 3. VISU afficher les commandes
idx = 0
infos.m_g("------ menu {} -----".format(titre))
for d in cmd_desc:
idx += 1
infos.m_g(" touche {} - ".format(idx) + d)
infos.m_g("------ fin menu {} -----".format(titre))
# 4. boucle utilisateur
import inc.inputkiz as inputkiz
import random
choix_fait = False
idx = -1
while True:
choix = inputkiz.input_seq()
if choix == "E": # Entrée : exécuter la commande actuelle
mpc.ferme_ton_clapet()
if choix_fait:
infos.m_g("exécuter ({}) - {}".format(touches, descrip))
executer()
break
else:
msg = "Taper un chiffre pour écouter une commande, " + \
"avant de la valider si elle vous convient," + \
"ou bien zéro pour quitter le menu vocal"
infos.pdrNew(msg)
elif choix == "33": # bascule mode vocal niveau 0 ou 3
tts_niveau_aide
elif choix == "...": # quitter l'appli
quitter
elif choix == "-": # - : baisser le son
mpc.vol_down()
elif choix == "+": # + : monter le son
mpc.vol_up()
elif choix in ".": # . : coupe aide sonore
mpc.ferme_ton_clapet()
elif choix in cles: # 1 à len(cmdz)
mpc.ferme_ton_clapet()
choix_fait = True
idx = int(choix) - 1
touches = cmdz[idx][TOUCHES]
executer = cmdz[idx][COMMANDE]
descrip = cmdz[idx][DESC]
# annoncer simplement l'action de la commande
msg1 = "touche {}, {}".format(choix, descrip)
msg2 = "touche {}, {}, pressez Entrée pour lancer cette action".format(choix, descrip)
# ~ msg2 = "appuyez sur Entrée pour {}".format(descrip)
infos.pdrNew( [msg1, msg2 ])
elif choix == "0": # 0 : quitter menu interactif
mpc.ferme_ton_clapet()
msg = "Fin du menu " + titre
infos.pdrNew(msg)
msg = "py_current_module="+ infos.ini_get("py_current_module", "PB_ICI")
infos.m_g(msg)
return "menu_vocal_0"
else:
msg = "choix invalide : " + str(choix) + \
", veuillez utiliser les chiffres de 1 à " + str(cles[-1]) + \
" , ou bien zéro pour quitter le menu " + titre
mpc.ferme_ton_clapet()
infos.pdrNew(msg)
def move_file_to_dir(full_src, dir_dst, make_dir_dst = True):
""" déplace un fichier avec les noms complets
ne prend pas en compte les fichiers avec espaces
full_src est un fichier
dir_dst est un dossier
ex : move_file_to_dir(full_src, dir_dst, make_dir = False)
"""
if not dir_exists(dir_dst):
if make_dir_dst:
if not make_dir(dir_dst):
msg = "move_file_to_dir(), le dossier n'a pas pu être créé"
infos.m_g(msg.format(dir_dst))
return False
else:
msg = "move_file_to_dir(), le dossier {} n'existe pas"
infos.m_g(msg.format(dir_dst))
return False
cmd = "mv {} {} && echo ok".format(full_src, dir_dst)
retour = mpc.sub_proc(cmd)
if retour:
return True
else:
msg = "move_file_to_dir(), ERR déplacement"
infos.m_g(msg.format(dir_dst))
return False
def make_dir(full_path):
""" crée un dossier complet
ne prend pas en compte les espaces
"""
if full_path.find(" ") > -1:
infos.m_g("make_dir(), le dossier contient des espaces : {}".format(full_path))
return False
cmd = "mkdir -p {} && echo ok".format(full_path)
retour = mpc.sub_proc(cmd)
if retour:
return True
else:
msg = "make_dir(), ERR création dossier {}"
infos.m_g(msg.format(dir_dst))
return False
def qu_mod_co():
""" on quitte le module ou on reste bloqué à l'accueil """
if infos.ini_get("py_current_module", "juk") in ["aba", "abk", "abw", "mtn", "rad", "rec", "zik"]:
##############################
# arrêter le module en cours #
# et mémoriser son état #
##############################
curr_modul = infos.ini_get("py_current_module")
infos.m_g("qu_mod_co : on quitte le module " + curr_modul)
if curr_modul == "aba":
from mod.aba import memo_stop_module
elif curr_modul == "mtn":
from mod.mtn import memo_stop_module
elif curr_modul == "rad":
from mod.rad import memo_stop_module
elif curr_modul == "rec":
from mod.rec import memo_stop_module
elif curr_modul == "zik":
from mod.zik import memo_stop_module
memo_stop_module()
mpc.clear() # doit arriver APRES la mémorisation
mpc.ferme_ton_clapet()
infos.ini_set("py_current_module", "juk")
infos.m_g("qu_mod_co : on bascule vers " + infos.ini_get("py_current_module", "juk"))
else:
##############################################
# si on est déjà à l'accueil (module "juk"), #
# arrêter la lecture avec mpc -q stop #
##############################################
msg = "Vous êtes à l'accueil du programme"
infos.pdrNew(msg)
# TODO : prononcer l'espace libre restant si appui sur 0 n fois
# n à déterminer
# càd que le user veut connaître l'espace restant
# en appuyant plusieurs fois de suite sur zéro
def quitter():
""" Quitter jukebox """
mpc.stop()
infos.m_g("Quitter jukebox (sans memo_stop_module)")
# nettoyer les téléchargements en cours, les fichiers témoin
cmd = "killall wget"
mpc.sub_proc(cmd)
cmd = "killall 7z"
mpc.sub_proc(cmd)
cmd = "touch /m/quitter_download"
mpc.sub_proc(cmd)
cmd = "touch /m/quitter_dire"
mpc.sub_proc(cmd)
cmd = "rm /m/aba_dl_bg*txt"
mpc.sub_proc(cmd)
cmd = "rm {}/*txt".format(cfg.DIRE_FILE_ATTENTE)
mpc.sub_proc(cmd)
# prononcer en natif ici, pas d'arrière-plan
# ~ texte = "Vous quittez l'application, abandon des téléchargements éventuels en cours."
infos.m_g("TODO dire abandon des téléchargements en cours s'il y en a")
texte = "Vous quittez l'application."
wav = cfg.WAV_WAV
cmd = 'pico2wave -l "fr-FR" -w ' + wav + ' "' + texte + '"'
infos.m_g(cmd)
mpc.sub_proc(cmd)
# jouer wav
cmd = "aplay -q " + wav
infos.m_g(cmd)
mpc.ferme_ton_clapet()
mpc.sub_proc(cmd)
mpc.stop()
faire_pause(3)
import sys
sys.exit(0)
def rebours05mn():
rebours_x_mn("5")
def rebours10mn():
rebours_x_mn("10")
def rebours15mn():
""" programme un arrêt du module dans 15 mn, TODO = programmer un arrêt à la demande """
rebours_x_mn("15")
def rebours_x_mn(minutes):
""" programme un arrêt du module """
infos.m_g("commun, EN COURS rebours" + minutes + "mn")
def stop():
import inc.mpc as mpc
mpc.stop()
def temper_ville(ville):
""" température temps réel d'une ville francaise """
villes = {
"Auxerre": "auxerre-perrigny/07266",
"Orléans": "orleans-bricy/07249",
"Metz" : "metz-nancy-lorraine/07093",
"Reims" : "reims-prunay/07072",
}
fInfoClimat = villes.get(ville)
infoclimat = "https://www.infoclimat.fr/observations-meteo/temps-reel/{}.html"
url = infoclimat.format(fInfoClimat)
fichier = "/tmp/aba_temperatures.txt"
mpc.sub_proc("wget -q -O {} {}".format(fichier, url))
cmd = "grep -o -E 'style=\"font-weight:bold;" + \
"display:inline-block;font-size:16px.{1,10}</span>' < " + \
fichier + " | head -1 | sed 's/<\|>/|/g' | cut -f2 -d'|'"
r = mpc.sub_proc(cmd)
return "Température à {} : {}".format(ville, r)
def temperatures (): # annonce qqs températures
""" température temps réel Auxerre et Reims """
infos.pdrNew(temper_ville("Reims"))
infos.pdrNew(temper_ville("Auxerre"))
def temperatures2():
""" température temps réel Metz et Orléans """
infos.pdrNew(temper_ville("Metz"))
infos.pdrNew(temper_ville("Orléans"))
def toggle():
import inc.mpc as mpc
mpc.toggle()
def aide_rapide_NEW(): # touches 00 = "aide rapide"
""" appui sur séquence touches 00 """
module_en_cours = infos.ini_get("py_current_module", "")
menu, clefs, clefs_DEV = aideVisuel(None, "module")
if module_en_cours == "aba":
import mod.aba as aba
aba.memo_pos_livre_aba()
mpc.stop() # vient après mémorisation memo_pos_livre_aba()
mpc.ferme_ton_clapet()
infos.pdrNew("aide rapide pour le module " + module_en_cours)
mask = "Voici la liste des {} commandes " + \
"associées aux touches du pavé numérique"
infos.pdrNew(mask.format(len(clefs)))
for i in clefs:
# pad string avec rjust
infos.pdrNew(str(i).rjust(4) + ', ' + menu.get(i)[1])
infos.pdrNew("Fin des commandes du module")
infos.m_g("")
for i in clefs_DEV:
infos.m_g("* DEV * " + str(i).rjust(4) + ', ' + menu.get(i)[1])
def touches_communes_NEW(): # touches 000 = touches communes
""" appui sur séquence touches 000
énonce tous les raccourcis communs
appuyer sur . pour arrêter les énoncés restants
"""
module_en_cours = infos.ini_get("py_current_module", "")
menu, clefs, clefs_DEV = aideVisuel(None, "commun")
if module_en_cours == "aba":
import mod.aba as aba
aba.memo_pos_livre_aba()
mpc.stop() # vient après mémorisation memo_pos_livre_aba()
mpc.ferme_ton_clapet()
# infos.pdrNew("touches communes à tous les modules, donc valables également pour " + module_en_cours)
mask = "Voici la liste des {} commandes communes " + \
"associées aux touches du pavé numérique"
infos.pdrNew(mask.format(len(clefs) + 2))
for i in clefs:
# pad string avec rjust
infos.pdrNew(str(i).rjust(4) + ', ' + menu.get(i)[1])
infos.pdrNew("point point point, quitter tout")
# infos.pdrNew("point point, lire une histoire drôle ou un proverbe au hasard")
infos.pdrNew("point, interrompre les messages vocaux")
infos.pdrNew("Fin des commandes communes du module")
infos.m_g("")
for i in clefs_DEV:
infos.m_g("* DEV * " + str(i).rjust(4) + ', ' + menu.get(i)[1])
# def aide_rapide(): # touches 00 = "aide rapide"
# """ appui sur séquence touches 00 """
# module_en_cours = infos.ini_get("py_current_module", "")
# if module_en_cours == "juk":
# mpc.ferme_ton_clapet()
# infos.pdrNew("00, aide rapide accueil")
# infos.pdrNew("appuyez sur 1 pour lancer la radio")
# infos.pdrNew("ou bien sur 2 pour lancer la musique")
# infos.pdrNew("sur 3 pour lancer les audiolivres")
# infos.pdrNew("sur 4 pour lancer la maintenance")
# infos.pdrNew("Pour chaque appareil, vous obtiendrez de l'aide grâce aux touches 00, 000 et 111")
# infos.pdrNew("Enfin, 11 déclenchera le menu vocal")
# infos.m_g("*** DEV 778 affichent touches module")
# infos.m_g("*** DEV 779 affichent touches communes")
# elif module_en_cours == "rad":
# mpc.ferme_ton_clapet()
# infos.pdrNew("00, aide rapide radio")
# infos.pdrNew("appuyez sur 1, 2 ou 3 pour lancer le groupe 1, 2 ou 3")
# infos.pdrNew("ou bien appuyez sur 22 pour écouter vos enregistrements")
# infos.pdrNew("ou enfin appuyez sur 11 pour écouter le menu vocal radio")
# elif module_en_cours == "zik":
# mpc.ferme_ton_clapet()
## cf. mnu_zik{} dans cfg.py
# infos.pdrNew("00, aide rapide musique")
# infos.pdrNew("appuyez sur 1 puis entrée pour lancer tout au hasard")
# infos.pdrNew("appuyez sur 2 pour écouter les favoris dans le désordre")
# infos.pdrNew("ou bien appuyez sur 11 pour écouter le menu vocal musique")
# elif module_en_cours == "mtn":
# mpc.ferme_ton_clapet()
# infos.pdrNew("00, aide rapide maintenance")
# infos.pdrNew("appuyez sur 88 pour mettre à jour")
# infos.pdrNew("appuyez sur 99 pour sauvegarder en local")
# infos.pdrNew("ou bien appuyez sur 11 pour écouter le menu vocal maintenance ")
# elif module_en_cours == "aba":
# import mod.aba as aba
# aba.memo_pos_livre_aba()
# mpc.stop() # vient après mémorisation memo_pos_livre_aba()
# mpc.ferme_ton_clapet()
# infos.pdrNew("00, aide rapide audiolivres")
# infos.pdrNew(
# "utilisez la touche 1 pour passer au livre précédent, " + \
# "ou la touche 3 pour passer au suivant")
# infos.pdrNew("tapez 2 pour prendre un livre au hasard")
# infos.pdrNew("La touche point, permet d'interrompre les longs messages vocaux, qui peuvent être ennuyeux.")
# infos.pdrNew("Pppuyez sur 11 pour écouter le menu vocal audiolivres")
def touches_module(): # touches 000 = touches modules
""" appui sur séquence touches 000 """
module_en_cours = infos.ini_get("py_current_module", "")
if module_en_cours == "juk":
mpc.ferme_ton_clapet()
infos.pdrNew("000, raccourcis navigation jukebox")
infos.pdrNew("appuyez sur 1 pour lancer la radio")
infos.pdrNew("appuyez sur 2 pour lancer la musique")
infos.pdrNew("appuyez sur 3 pour lancer les audiolivres")
infos.pdrNew("appuyez sur 4 pour lancer la maintenance")
elif module_en_cours == "rad":
mpc.ferme_ton_clapet()
infos.pdrNew("000, raccourcis navigation radio")
infos.pdrNew("appuyez sur 22 pour écouter les enregistrements")
infos.pdrNew("appuyez sur 4 pour passer à la station précédente, 6 pour la suivante")
infos.pdrNew("appuyez sur 85 pour une pause publicité de une minute")
elif module_en_cours == "zik":
mpc.ferme_ton_clapet()
infos.pdrNew("000, raccourcis navigation musique")
infos.pdrNew("appuyez sur 7 pour reculer de 10 secondes, 9 pour avancer de 30 secondes")
infos.pdrNew("appuyez sur 22 pour écouter seulement le dossier courant")
infos.pdrNew("appuyez sur * une fois pour ajouter aux favoris, deux fois pour supprimer")
elif module_en_cours == "mtn":
mpc.ferme_ton_clapet()
infos.pdrNew("000, pas de raccourcis navigation pour le module maintenance")
elif module_en_cours == "aba":
import mod.aba as aba
aba.memo_pos_livre_aba()
mpc.ferme_ton_clapet()
infos.pdrNew("000, raccourcis de navigation pour le module audiolivres")
infos.pdrNew(
"appuyez sur 6 pour passer au chapitre suivant, " + \
"ou sur 4 pour le chapitre précédent." + \
"Ou bien sur 44 pour aller au premier," + \
"ou sur 66 pour sauter dsirectement au dernier." + \
"Les touches 7 et 9 permettent respectivement de " + \
"reculer de 10 secondes ou avancer de 30 secondes." + \
"")
def touche_retour_arriere():
"""
"""
msg = "Appui sur touche retour arrière"
infos.pdrNew(msg)
def tts_basculer():
""" modifie système synthèse vocale pico2wave/google """
if infos.ini_get("moteur_tts", "pico2wave") == "pico2wave":
new_moteur = "google"
else:
new_moteur = "pico2wave"
infos.ini_set("moteur_tts", new_moteur)
def tts_niveau_aide():
""" modifie le niveau d'aide sonore """
v = infos.ini_get("py_niv_aide_voc", "3")
if v == "3":
v = "0"
else:
v = "3"
# on inverse le niveau vcoal, qui bascule entre
# les deux valeurs 0 ou 3
infos.ini_set("py_niv_aide_voc", v)
if v == "0":
msg = "Désactivation de l'aide vocale"
else:
msg = "L'aide vocale devient active"
infos.pdrNew(msg)
def vol_down():
mpc.vol_down("info")
def vol_down2():
mpc.vol_down2("info")
def vol_up():
mpc.vol_up("info")
def vol_up2():
mpc.vol_up2("info")
def vol_down4():
mpc.vol_down4("info")