Partager via

Reconnaissance vocale Android

  • Article

Cet article décrit les principes de base de l’utilisation de l’espace de noms Android.Speech très puissant. Depuis sa création, Android a pu reconnaître la voix et la générer en tant que texte. Il s’agit d’un processus relativement simple. Toutefois, pour la synthèse vocale, le processus est plus impliqué, car non seulement le moteur de reconnaissance vocale doit être pris en compte, mais également les langues disponibles et installées à partir du système TTS (Text To Speech).

Vue d’ensemble de speech

Le fait d’avoir un système qui « comprend » la parole humaine et instancie ce qui est tapé ( reconnaissance vocale et synthèse vocale ) est une zone toujours plus importante au sein du développement mobile, car la demande de communication naturelle avec nos appareils augmente. Il existe de nombreuses instances où une fonctionnalité qui convertit du texte en parole, ou inversement, est un outil très utile à incorporer dans votre application Android.

Par exemple, avec la répression sur l’utilisation du téléphone mobile lors de la conduite, les utilisateurs veulent un moyen mains libres d’utiliser leurs appareils. L’pléthore de différents facteurs de forme Android( comme Android Wear) et l’inclusion toujours étendue de ceux capables d’utiliser des appareils Android (tels que des tablettes et des pavés de notes), a créé une plus grande concentration sur de grandes applications TTS.

Google fournit au développeur un ensemble complet d’API dans l’espace de noms Android.Speech pour couvrir la plupart des instances de création d’un appareil « prenant en charge la reconnaissance vocale » (par exemple, les logiciels conçus pour les aveugles). L’espace de noms inclut la fonctionnalité permettant de traduire du texte en reconnaissance vocale Android.Speech.Tts, de contrôler le moteur utilisé pour effectuer la traduction, ainsi qu’un certain nombre de RecognizerIntents qui permettent la conversion vocale en texte.

Bien que les installations soient là pour que la parole soit comprise, il existe des limitations basées sur le matériel utilisé. Il est peu probable que l’appareil interprète correctement tout ce qui lui est parlé dans chaque langue disponible.

Spécifications

Il n’existe aucune exigence particulière pour ce guide, autre que votre appareil disposant d’un microphone et d’un haut-parleur.

Le cœur d’un appareil Android interprétant la voix est l’utilisation d’un Intent avec un appareil correspondant OnActivityResult. Toutefois, il est important de reconnaître que le discours n’est pas compris, mais interprété en texte. La différence est importante.

Différence entre la compréhension et l’interprétation

Une définition simple de la compréhension est que vous pouvez déterminer par ton et contexte la signification réelle de ce qui est dit. Pour interpréter simplement des moyens de prendre les mots et de les générer sous une autre forme.

Considérez l’exemple simple suivant qui est utilisé dans la conversation quotidienne :

Bonjour, comment vas-tu?

Sans inflexion (accent mis sur des mots spécifiques ou des parties de mots), il s’agit d’une question simple. Toutefois, si un rythme lent est appliqué à la ligne, la personne à l’écoute détecte que l’asker n’est pas trop heureux et peut-être a besoin de remonter le moral ou que l’asker est mal. Si l’accent est mis sur « sont », la personne demandant est généralement plus intéressée par la réponse.

Sans traitement audio assez puissant pour utiliser l’inflexion et un degré d’intelligence artificielle (IA) pour comprendre le contexte, le logiciel ne peut même pas commencer à comprendre ce qui a été dit, le meilleur qu’un téléphone simple peut faire est de convertir la parole en texte.

Configuration

Avant d’utiliser le système de reconnaissance vocale, il est toujours judicieux de case activée pour vous assurer que l’appareil dispose d’un microphone. Il y aurait peu de points d’essayer d’exécuter votre application sur un Bloc-notes Kindle ou Google sans microphone installé.

L’exemple de code ci-dessous illustre l’interrogation si un microphone est disponible et, si ce n’est pas le cas, pour créer une alerte. Si aucun microphone n’est disponible à ce stade, vous quittez l’activité ou désactivez la possibilité d’enregistrer la voix.

string rec = Android.Content.PM.PackageManager.FeatureMicrophone;
if (rec != "android.hardware.microphone")
{
    var alert = new AlertDialog.Builder(recButton.Context);
    alert.SetTitle("You don't seem to have a microphone to record with");
    alert.SetPositiveButton("OK", (sender, e) =>
    {
        return;
    });
    alert.Show();
}

Création de l’intention

L’intention du système vocal utilise un type particulier d’intention appelé le RecognizerIntent. Cette intention contrôle un grand nombre de paramètres, notamment la durée d’attente avec le silence jusqu’à ce que l’enregistrement soit considéré comme terminé, toutes les langues supplémentaires à reconnaître et à générer, ainsi que tout texte à inclure dans la Intentboîte de dialogue modale comme moyen d’instruction. Dans cet extrait de code, VOICE est utilisé readonly int pour la reconnaissance dans OnActivityResult.

var voiceIntent = new Intent(RecognizerIntent.ActionRecognizeSpeech);
voiceIntent.PutExtra(RecognizerIntent.ExtraLanguageModel, RecognizerIntent.LanguageModelFreeForm);
voiceIntent.PutExtra(RecognizerIntent.ExtraPrompt, Application.Context.GetString(Resource.String.messageSpeakNow));
voiceIntent.PutExtra(RecognizerIntent.ExtraSpeechInputCompleteSilenceLengthMillis, 1500);
voiceIntent.PutExtra(RecognizerIntent.ExtraSpeechInputPossiblyCompleteSilenceLengthMillis, 1500);
voiceIntent.PutExtra(RecognizerIntent.ExtraSpeechInputMinimumLengthMillis, 15000);
voiceIntent.PutExtra(RecognizerIntent.ExtraMaxResults, 1);
voiceIntent.PutExtra(RecognizerIntent.ExtraLanguage, Java.Util.Locale.Default);
StartActivityForResult(voiceIntent, VOICE);

Conversion de la parole

Le texte interprété à partir de la parole est remis dans le Intentfichier , qui est retourné lorsque l’activité a été terminée et est accessible via GetStringArrayListExtra(RecognizerIntent.ExtraResults). Cela renverra un IList<string>, dont l’index peut être utilisé et affiché, en fonction du nombre de langues demandées dans l’intention de l’appelant (et spécifié dans le RecognizerIntent.ExtraMaxResults). Comme pour n’importe quelle liste, il vaut la peine d’case activée pour vous assurer qu’il existe des données à afficher.

Lorsque vous écoutez la valeur de retour d’un StartActivityForResult, la OnActivityResult méthode doit être fournie.

Dans l’exemple ci-dessous, textBox est utilisé TextBox pour sortir ce qui a été dicté. Il peut également être utilisé pour passer le texte à une forme d’interpréteur et à partir de là, l’application peut comparer le texte et la branche à une autre partie de l’application.

protected override void OnActivityResult(int requestCode, Result resultVal, Intent data)
{
    if (requestCode == VOICE)
    {
        if (resultVal == Result.Ok)
        {
            var matches = data.GetStringArrayListExtra(RecognizerIntent.ExtraResults);
            if (matches.Count != 0)
            {
                string textInput = textBox.Text + matches[0];
                textBox.Text = textInput;
                switch (matches[0].Substring(0, 5).ToLower())
                {
                    case "north":
                        MovePlayer(0);
                        break;
                    case "south":
                        MovePlayer(1);
                        break;
                }
            }
            else
            {
                textBox.Text = "No speech was recognised";
            }
        }
        base.OnActivityResult(requestCode, resultVal, data);
    }
}

Synthèse vocale

La synthèse vocale n’est pas tout à fait l’inverse de la reconnaissance vocale et repose sur deux composants clés ; un moteur de synthèse vocale installé sur l’appareil et une langue installée.

En grande partie, les appareils Android sont fournis avec le service Google TTS par défaut installé et au moins une langue. Ceci est établi lorsque l’appareil est configuré pour la première fois et sera basé sur l’emplacement où l’appareil est à l’heure (par exemple, un téléphone configuré en Allemagne installera la langue allemande, tandis qu’un en Amérique aura l’anglais américain).

Étape 1 : instanciation de TextToSpeech

TextToSpeech peut prendre jusqu’à 3 paramètres, les deux premiers sont requis avec le troisième étant facultatif (AppContext, IOnInitListener, engine). L’écouteur est utilisé pour lier le service et tester l’échec avec le moteur étant n’importe quel nombre de texte Android disponibles vers les moteurs de reconnaissance vocale. Au minimum, l’appareil aura le moteur de Google.

Étape 2 : recherche des langues disponibles

La Java.Util.Locale classe contient une méthode utile appelée GetAvailableLocales(). Cette liste de langues prises en charge par le moteur de reconnaissance vocale peut ensuite être testée par rapport aux langues installées.

Il s’agit d’une question triviale de générer la liste des langues « comprises ». Il y aura toujours une langue par défaut (la langue définie par l’utilisateur lors de la première configuration de son appareil), par conséquent, dans cet exemple, le List<string> paramètre « Par défaut » est le premier paramètre, le reste de la liste sera rempli en fonction du résultat du textToSpeech.IsLanguageAvailable(locale).

var langAvailable = new List<string>{ "Default" };
var localesAvailable = Java.Util.Locale.GetAvailableLocales().ToList();
foreach (var locale in localesAvailable)
{
    var res = textToSpeech.IsLanguageAvailable(locale);
    switch (res)
    {
        case LanguageAvailableResult.Available:
          langAvailable.Add(locale.DisplayLanguage);
          break;
        case LanguageAvailableResult.CountryAvailable:
          langAvailable.Add(locale.DisplayLanguage);
          break;
        case LanguageAvailableResult.CountryVarAvailable:
          langAvailable.Add(locale.DisplayLanguage);
          break;
    }
}
langAvailable = langAvailable.OrderBy(t => t).Distinct().ToList();

Ce code appelle TextToSpeech.IsLanguageAvailable pour tester si le package de langue d’un paramètre régional donné est déjà présent sur l’appareil. Cette méthode retourne un LanguageAvailableResult, qui indique si la langue des paramètres régionaux passés est disponible. S’il LanguageAvailableResult indique que la langue est NotSupported, il n’existe aucun package vocal disponible (même pour le téléchargement) pour cette langue. Si LanguageAvailableResult la valeur est définie MissingData, il est possible de télécharger un nouveau package de langue, comme expliqué ci-dessous à l’étape 4.

Étape 3 : définition de la vitesse et de la hauteur

Android permet à l’utilisateur de modifier le son de la parole en modifiant la SpeechRate vitesse et Pitch (vitesse et tonalité de la parole). Cela passe de 0 à 1, avec la parole « normale » étant 1 pour les deux.

Étape 4 : test et chargement de nouvelles langues

Le téléchargement d’une nouvelle langue est effectué à l’aide d’un Intent. Le résultat de cette intention entraîne l’appel de la méthode OnActivityResult . Contrairement à l’exemple de reconnaissance vocale (qui a utilisé RecognizerIntent comme PutExtra paramètre pour le Intent), les tests et les chargements Intentsont basés sur Action:

L’exemple de code suivant montre comment utiliser ces actions pour tester les ressources linguistiques et télécharger une nouvelle langue :

var checkTTSIntent = new Intent();
checkTTSIntent.SetAction(TextToSpeech.Engine.ActionCheckTtsData);
StartActivityForResult(checkTTSIntent, NeedLang);
//
protected override void OnActivityResult(int req, Result res, Intent data)
{
    if (req == NeedLang)
    {
        var installTTS = new Intent();
        installTTS.SetAction(TextToSpeech.Engine.ActionInstallTtsData);
        StartActivity(installTTS);
    }
}

TextToSpeech.Engine.ActionCheckTtsData teste la disponibilité des ressources linguistiques. OnActivityResult est appelé lorsque ce test est terminé. Si les ressources linguistiques doivent être téléchargées, OnActivityResult déclenche l’action TextToSpeech.Engine.ActionInstallTtsData pour démarrer une activité qui permet à l’utilisateur de télécharger les langues nécessaires. Notez que cette OnActivityResult implémentation n’case activée pas le Result code, car, dans cet exemple simplifié, la détermination a déjà été faite que le package de langue doit être téléchargé.

L’action TextToSpeech.Engine.ActionInstallTtsData entraîne la présentation de l’activité de données vocales Google TTS à l’utilisateur pour choisir les langues à télécharger :

Activité des données vocales Google TTS

Par exemple, l’utilisateur peut choisir Français et cliquer sur l’icône de téléchargement pour télécharger Français données vocales :

Exemple de téléchargement de Français langue

L’installation de ces données se produit automatiquement une fois le téléchargement terminé.

Étape 5 : IOnInitListener

Pour qu’une activité puisse convertir le texte en parole, la méthode OnInit d’interface doit être implémentée (il s’agit du deuxième paramètre spécifié pour l’instanciation de la TextToSpeech classe). Cela initialise l’écouteur et teste le résultat.

L’écouteur doit tester les deux OperationResult.Success et OperationResult.Failure au minimum. L’exemple suivant montre simplement ce qui suit :

void TextToSpeech.IOnInitListener.OnInit(OperationResult status)
{
    // if we get an error, default to the default language
    if (status == OperationResult.Error)
        textToSpeech.SetLanguage(Java.Util.Locale.Default);
    // if the listener is ok, set the lang
    if (status == OperationResult.Success)
        textToSpeech.SetLanguage(lang);
}

Résumé

Dans ce guide, nous avons examiné les principes fondamentaux de la conversion de texte en synthèse vocale et vocale et des méthodes possibles pour les inclure dans vos propres applications. Bien qu’ils ne couvrent pas chaque cas particulier, vous devez maintenant avoir une compréhension de base de la façon dont la parole est interprétée, comment installer de nouvelles langues et comment augmenter l’inclusivité de vos applications.