RECONNAISSANCE VOCALE

# -*- coding: utf-8 -*-

# -----------------------------------------------------------------------------
# Les modules
# -----------------------------------------------------------------------------
import win32com.client, pythoncom # pour utiliser les objets COM
import win32api # contient la méthode PostQuitMessage() permettant d'envoyer le message WM_QUIT
                # pour arrêter le script (existe aussi dans le module win32gui)
import os # contient la méthode startfile() pour lancer un exécutable
import os.path # contient la fonction permettant de tester si un fichier existe

    
# -----------------------------------------------------------------------------
# Les constantes de l'API relatives à la reconnaissance vocale
# -----------------------------------------------------------------------------
class SpeechLoadOption: 
    """Constantes : les options de chargement d'une grammaire xml"""
    SLOStatic = 0
    SLODynamic = 1

class SpeechRuleState: 
    """Constantes : les status des règles de la grammaire"""
    SGDSInactive = 0
    SGDSActive = 1
    SGDSActiveWithAutoPause = 3

class SpeechRecoContextState: 
    """Constantes : les status du contexte"""
    SRCS_Disabled = 0
    SRCS_Enabled = 1

class SpeechRecoEvents: 
    """Constantes : les évènements de la reconnaissance vocale"""
    SREStreamEnd = 1
    SRESoundStart = 2
    SRESoundEnd = 4
    SREPhraseStart = 8
    SRERecognition = 16
    SREHypothesis = 32
    SREBookmark = 64
    SREPropertyNumChange = 128
    SREPropertyStringChange = 256
    SREFalseRecognition = 512
    SREInterference = 1024
    SRERequestUI = 2048
    SREStateChange = 4096
    SREAdaptation = 8192
    SREStreamStart = 16384
    SRERecoOtherContext = 32768
    SREAudioLevel = 65536
    SREPrivate = 262144
    SREAllEvents = 393215

class SpeechEngineConfidence:
    """Constantes : niveaux de fiabilité de la reconnaissance"""
    SECLowConfidence = -1
    SECNormalConfidence = 0
    SECHighConfidence = 1

class SpeechGrammarState:
    """Constantes : le statut de la grammaire"""
    SGSDisabled = 0
    SGSEnabled = 1
    SGSExclusive = 3

class SpeechGrammarWordType:
    """Constantes : les types de mots dans une grammaire"""
    SGDisplay = 0
    SGLexical = 1
    SGPronounciation = 2

# -----------------------------------------------------------------------------
# La gestion des évènements issus du contexte de la reconnaissance vocale
# -----------------------------------------------------------------------------
        
def fiabilite(les_mots):
    """Pour chaque mot, si le niveau de fiabilité est inférieur au niveau requis, alors renvoie False.
        Paramètre : 
            les_mots : ensemble des mots reconnus"""
    
    fiable = True
    nb_mots = les_mots.Count
    for i in range(nb_mots):
        mot = les_mots.Item(i)
        if mot.ActualConfidence < mot.RequiredConfidence:
            fiable = False
            break
    return fiable

def executer_action(prop):
    """L'action associée à la phrase reconnue est exécutée.
        Paramètre :
            prop : la propriété (.PhraseInfo.Properties.Item(0))"""

    nom = prop.Name.lower()
    val = prop.Value
    if  nom == "executable" and val != None: # lancer un programme
        list_prog = val.split("?")
        for i in range(len(list_prog)):
            if os.path.isfile(list_prog[i]) == True:
                print("Exécution de : " + repr(list_prog[i]))
                os.startfile(list_prog[i]) # lance le prog. et "rend la main"
            else:
                print("Le programme à exécuter n'existe pas")
    elif nom == "fin_script": # fin du script
        win32api.PostQuitMessage(0)
    else:
        print("Aucune action")
           
class gestion_evenement:
    """Cette classe exécute les actions déclenchées par un évènement de la 
        reconnaissance vocale. Elle est déclarée par 
            win32com.client.DispatchWithEvents("SAPI.SpSharedRecoContext", <nom de la classe>).
        Un évènement est traité par une seule méthode nommée :
            On<nom de l'évènement>"""

    def OnStartStream(self, StreamNumber, StreamPosition):
        """Déclenché lorsque le contexte de reconnaissance est actif (autrement
        dit, dès le début)."""
        print("---------------------------------------")
        print("| La reconnaissance vocale est active |")
        print("---------------------------------------")
        
    def OnRecognition(self, StreamNumber, StreamPosition, RecognitionType, Result):
        """Déclenché lorsque la reconnaissance vocale identifie un mot
        de la grammaire. Parfois cet évènement survient, mais le texte de Result est vide."""
        
        result_reco = win32com.client.Dispatch(Result) # "récupérer" l'interface de l'objet (cf doc)
        Result = None
        if result_reco.PhraseInfo.GetText() != "" and fiabilite(result_reco.PhraseInfo.Elements) == True:
            print("\nLa phrase reconnue est : " + result_reco.PhraseInfo.GetText())
            executer_action(result_reco.PhraseInfo.Properties.Item(0))
            
def liste_des_logiciels(gramm):
    """Convertit la liste de logiciels en règles de grammaire. Retourne True si l'ajout de ces
        règles à la grammaire se déroule avec succès ; False sinon.
        Paramètre :
            gramm : la grammaire fixe"""
    
    les_regles = gramm.Rules
    liste_des_logiciels = les_regles.FindRule("liste_des_logiciels") # règle correspondant à la liste
    
    if liste_des_logiciels == None: # la liste n'existe pas
        print("Erreur la règles correspondant à la liste des logiciels n'existe pas => vérifier le fichier xml.")
        return False
        
    liste_des_logiciels.Clear()
    
    propriete = "executable" # nom de la propriété
    # ajoute '+' devant le nom du logiciel pour définir le niveau de fiabilité requise à HIGH
    # définition du dictionnaire ou la clé est le nom du logiciel ayant pour valeur le
    # chemin d'accès à l'exécutable ; s'il y a plusieurs exécutables alors ils sont séparés par '?' (ce
    # caractère n'existe pas dans le noms de fichiers windows)
    dict_executable = { "+word" : "C:\\Program Files\\Microsoft Office\\Office10\\WINWORD.EXE", "+wordpad" : "C:\\Program Files\\Windows NT\\Accessoires\\wordpad.exe", "+explorateur" : "C:\\mes_programmes\\xplorer2_lite\\xplorer2_lite.exe", "+python" : "C:\\mes_programmes\\Notepad++\\notepad++.exe?C:\\Documents and Settings\\All Users\\Menu Démarrer\\Programmes\\Python 3.1\\IDLE (Python GUI).lnk?C:\\Documents and Settings\\All Users\Menu Démarrer\Programmes\\Python 3.1\\Python Manuals.lnk", "+navigateur" : "C:\\Documents and Settings\\All Users\\Menu Démarrer\\Programmes\\Navigateur\\Google Chrome\\Google Chrome.lnk", "+bloc note" : "C:\\Documents and Settings\\All Users\\Menu Démarrer\\Programmes\\Mes utilitaires\\Notepad2.lnk", "+video" : "C:\\mes_programmes\\VLC\\vlc.exe" }
    for logiciel, executable in dict_executable.items():
        liste_des_logiciels.InitialState.AddWordTransition(None, logiciel, " ", SpeechGrammarWordType.SGLexical, 
        propriete, 0, executable, 1)
    
    les_regles.Commit()
    return True
           
# -----------------------------------------------------------------------------
# Le corps du script exécuté au lancement
# -----------------------------------------------------------------------------
if __name__ == "__main__":
    # créer le contexte en déclarant la gestion des évènements
    contexte = win32com.client.DispatchWithEvents("SAPI.SpSharedRecoContext", gestion_evenement)
    if contexte.State != SpeechRecoContextState.SRCS_Enabled:
        print("Le contexte de reconnaissance n'est pas actif.")

    # ce fichier contient la partie fixe de la grammaire
    fichier_gramm = "grammaire.xml"
 
    # chargement de la partie fixe
    gramm = contexte.CreateGrammar(0) # l'id de la grammaire est zéro
    gramm.State = SpeechGrammarState.SGSDisabled # la grammaire est inactive durant son chargement
    gramm.CmdLoadFromFile(fichier_gramm, SpeechLoadOption.SLODynamic)
    
    # converti la liste des logiciels
    if liste_des_logiciels(gramm) == True: # la grammaire a été modifiée avec succés
    
        # activer la grammaire et les règles
        gramm.State = SpeechGrammarState.SGSEnabled
        gramm.CmdSetRuleIdState(0, SpeechRuleState.SGDSActive)

        # gérer les évènements
        contexte.EventInterests = SpeechRecoEvents.SREStreamStart + SpeechRecoEvents.SRERecognition
    
        # écouter les évènements
        pythoncom.PumpMessages()
        
    print("fin")