Accessibilité pour les applications iOS: reconnaissance vocale

Les développeurs s’efforcent constamment de rendre leurs applications plus avancées, mais sont-elles réellement utilisables par tout le monde? Pour la plupart des applications, la réponse est non. Afin d’atteindre le plus large public, découvrons les moyens de rendre nos applications plus accessibles.

Suivi des Nations Unies ‘ Journée internationale des personnes handicapées, voyons comment nous pouvons rendre nos applications iOS plus accessibles.

Dans ce didacticiel, nous utiliserons AVAudioEngine pour transcrire la parole et l’afficher à l’utilisateur sous forme de texte (tout comme Siri le fait sur votre iPhone).

Ce didacticiel suppose que vous maîtrisez Swift et que vous maîtrisez l’utilisation de Xcode pour le développement iOS.

Configuration du projet

Pour suivre, vous pouvez créer un nouveau projet dans Xcode ou télécharger l’exemple de projet pour cette application.

Si vous travaillez à partir d’un nouveau projet, ajoutez la ligne suivante au sommet de votre ViewController.swift fichier afin que l’API Speech soit importée.

import Speech

Une autre étape que vous devez franchir avant de commencer est de faire le ViewController() classe conforme à la SFSpeechRecognizerDelegate.

Une fois que cela est fait, vous êtes prêt à commencer le didacticiel.

1. Demander la permission

Étant donné qu’Apple prend la confidentialité au sérieux, il est logique d’exiger des développeurs qu’ils demandent la permission aux utilisateurs avant d’utiliser les microphones de l’appareil, d’autant plus que les données sont envoyées aux serveurs d’Apple pour analyse.

Dans le cas de la reconnaissance vocale, une autorisation est requise car les données sont transmises et stockées temporairement sur les serveurs d’Apple pour augmenter la précision de la reconnaissance. Documentation Apple

Dans votre projet Xcode, vous devrez ouvrir votre Info.plist fichier et ajoutez deux paires clé-valeur. Voici les clés que vous pouvez coller:

• NSMicrophoneUsageDescription
• NSSpeechRecognitionUsageDescription

Pour les valeurs, vous pouvez entrer n’importe quelle chaîne décrivant avec précision les autorisations souhaitées et pourquoi vous en aurez besoin. Voici à quoi cela devrait ressembler une fois qu’ils sont ajoutés:

Maintenant, nous devrons demander l’autorisation à l’utilisateur avant de pouvoir continuer. Pour ce faire, nous pouvons simplement appeler une méthode, appelée commodément requestAuthorization().

Mais avant de faire ça, à l’intérieur de votre viewDidLoad() méthode, ajoutez la ligne de code suivante:

microphoneButton.isEnabled = false

Par défaut, cela rendra le bouton désactivé, de sorte qu’il n’y ait aucune chance que l’utilisateur puisse appuyer sur le bouton avant que l’application ait une chance de vérifier avec l’utilisateur.

Ensuite, vous devrez ajouter l’appel de méthode suivant:

SFSpeechRecognizer.requestAuthorization { (status) in
    OperationQueue.main.addOperation {
        // Your code goes here
    }
}

Dans le gestionnaire d’achèvement de cette méthode, nous recevons le statut de l’autorisation, puis le définissons sur une constante appelée status. Après cela, nous avons un appel asynchrone qui ajoute le code à l’intérieur du bloc au thread principal (puisque l’état du bouton doit être changé dans le thread principal).

À l’intérieur du addOperation bloquer, vous devrez ajouter ce qui suit switch instruction pour vérifier le statut de l’autorisation:

switch status {

  case .authorized: dictationButton.isEnabled = true
    promptLabel.text = "Tap the button to begin dictation..."

  default: dictationButton.isEnabled = false
    promptLabel.text = "Dictation not authorized..."
    
}

Nous activons la valeur de retour du authorizationStatus() fonction. Si l’action est autorisée (status est .authorized), le bouton de dictée est activé et Appuyez sur le bouton pour commencer la dictée … est affiché. Sinon, le bouton de dictée est désactivé et Dictée non autorisée … est affiché.

2. Conception de l’interface utilisateur

Ensuite, nous devrons concevoir une interface utilisateur pour pouvoir faire deux choses: démarrer ou arrêter la dictée et afficher le texte interprété. Pour ce faire, dirigez-vous vers le Main.storyboard fichier.

Voici les trois éléments du générateur d’interface dont vous aurez besoin pour poursuivre ce didacticiel:

• UILabel
• UITextView
• UIButton

Étant donné que le placement n’est pas essentiel dans cette application, je ne couvrirai pas exactement où et comment tout placer, alors suivez simplement ce filaire de base lorsque vous placez les éléments de votre interface utilisateur:

Comme point de référence, voici à quoi ressemble mon storyboard à ce stade:

Encore une fois, ce n’est pas grave si votre mise en page est différente, mais assurez-vous simplement que vous avez les trois mêmes éléments de base dans le filaire. Maintenant, collez les lignes de code suivantes vers le haut de votre ViewController() classe:

@IBOutlet var promptLabel: UILabel!
@IBOutlet var transcribedTextView: UITextView!
@IBOutlet var dictationButton: UIButton!

Vers le bas de la ViewController() classe, ajoutez simplement la fonction suivante à déclencher lorsque vous appuyez sur le bouton de dictée:

@IBAction func dictationButtonTapped() {
    // Your code goes here
}

La dernière chose à faire est d’ouvrir le Rédacteur adjoint et connectez les connexions du générateur d’interface à votre Main.storyboard fichier. Les points qui apparaissent à côté d’eux devraient maintenant apparaître remplis, et vous pourrez maintenant accéder à tous ces éléments en tant que variables et méthodes, respectivement.

3. Ajouter des variables

Maintenant, nous sommes enfin prêts à démarrer la reconnaissance vocale. La première étape consiste à créer les variables et les constantes appropriées que nous utiliserons tout au long du processus. Sous vos sorties de générateur d’interface, ajoutez les lignes de code suivantes:

let audioEngine = AVAudioEngine()
let speechRecognizer = SFSpeechRecognizer(locale: Locale(identifier: "en-US"))!

var request: SFSpeechAudioBufferRecognitionRequest?
var task: SFSpeechRecognitionTask?

Voici une description de ce que font les variables et les constantes:

• audioEngine est une instance de AVAudioEngine() classe. Cette classe est, en termes simples, une série de nœuds audio. Les nœuds audio sont utilisés pour faire diverses choses avec l’audio, comme la générer et le traiter.
• speechRecognizer est une instance de SFSpeechRecognizer() classe. Cette classe ne reconnaît rien d’autre que la langue spécifiée – dans ce cas, l’anglais américain.
• request est une variable optionnelle de type SFSpeechAudioBufferRecognitionRequest, et il est actuellement en cours d’initialisation nil. Plus tard dans ce didacticiel, nous en créerons un et définirons sa valeur lorsque nous aurons besoin de l’utiliser. Cela sera utilisé pour reconnaître les données d’entrée du microphone de l’appareil.
• task est une autre variable optionnelle, cette fois de type SFSpeechRecognition. Plus tard, nous utiliserons cette variable pour suivre la progression de notre reconnaissance vocale.

Après avoir ajouté les variables, vous disposez de tout ce dont vous avez besoin pour plonger directement dans le processus de reconnaissance vocale.

4. Déclaration de la méthode de dictée

Nous allons maintenant créer la méthode principale de notre algorithme de reconnaissance vocale. Sous le viewDidLoad() méthode, déclarez la fonction suivante:

func startDictation() {
    // Your code goes here
}

Puisque nous ne connaissons pas l’état actuel de la task, nous devrons annuler la tâche en cours, puis nous devons la remettre à nil (au cas où ce ne serait pas déjà le cas). Cela peut être fait en ajoutant les deux lignes de code suivantes dans votre méthode:

task?.cancel()
task = nil

Génial! Nous savons maintenant qu’aucune tâche n’est déjà en cours d’exécution. Il s’agit d’une étape importante lorsque vous utilisez des variables déclarées en dehors de la portée de la méthode. Une chose à noter est que nous utilisons le chaînage facultatif pour appeler cancel() sur task. C’est une manière concise d’écrire que nous voulons seulement appeler cancel() si task n’est pas nul.

5. Initialisation des variables

Maintenant, nous devons initialiser les variables que nous avons créées précédemment dans ce tutoriel. Pour continuer, ajoutez ces lignes de code à votre startDictation() méthode de l’étape précédente:

request = SFSpeechAudioBufferRecognitionRequest()

let audioSession = AVAudioSession.sharedInstance()

let inputNode = audioEngine.inputNode

guard let request = request else { return }
request.shouldReportPartialResults = true

try? audioSession.setCategory(AVAudioSessionCategoryRecord)
try? audioSession.setMode(AVAudioSessionModeMeasurement)
try? audioSession.setActive(true, with: .notifyOthersOnDeactivation)

Décomposons-le. Se souvenir du request variable que nous avons créée plus tôt? La première ligne de code initialise cette variable avec une instance du SFSpeechAudioBufferRecognitionRequest classe.

Ensuite, nous affectons l’instance de session audio partagée à une constante appelée audioSession. La session audio se comporte comme un intermédiaire entre l’application et l’appareil lui-même (et les composants audio).

Après cela, nous définissons le nœud d’entrée sur un singleton appelé inputNode. Pour commencer l’enregistrement, nous créerons plus tard un tap sur ce nœud.

Ensuite, nous utilisons un garde pour déballer le request variable que nous avons initialisée plus tôt. C’est simplement pour éviter d’avoir à déballer ceci plus tard dans l’application. Ensuite, nous activerons l’affichage des résultats incomplets. Cela fonctionne de la même manière que la dictée sur l’iPhone – si vous avez déjà utilisé la dictée, vous saurez que le système tape tout ce qu’il pense, puis, en utilisant des indices de contexte, ajuste les choses si nécessaire.

Enfin, les trois dernières lignes de code tentent de définir divers attributs de la session audio. Ces opérations peuvent générer des erreurs, elles doivent donc être marquées du symbole try? mot-clé. Pour gagner du temps, nous ignorerons simplement les erreurs qui se produisent.

Nous avons maintenant initialisé la plupart des variables qui étaient auparavant à l’état nul. Une dernière variable à initialiser est la task variable. Nous ferons cela à la prochaine étape.

6. Initialisation de la variable de tâche

L’initialisation de cette variable nécessitera un gestionnaire de complétion. Collez le code suivant au bas de votre startDictation() méthode:

task = speechRecognizer.recognitionTask(with: request, resultHandler: { (result, error) in
    
    guard let result = result else { return }
    self.transcribedTextView.text = result.bestTranscription.formattedString
    
    if error != nil || result.isFinal {
        self.audioEngine.stop()
        self.request = nil
        self.task = nil
        
        inputNode.removeTap(onBus: 0)
    }
})

Tout d’abord, nous créons un recognitionTask avec le request comme paramètre. Le deuxième paramètre est une fermeture définissant le gestionnaire de résultats. le result paramètre est une instance de SFSpeechRecognitionResult. Dans ce gestionnaire de complétion, nous devons à nouveau déplier la variable de résultat.

Ensuite, nous définissons le texte de notre vue texte comme étant la meilleure transcription que l’algorithme puisse fournir. Ce n’est pas nécessairement parfait, mais c’est ce que l’algorithme pense que correspond le mieux à ce qu’il a entendu.

Enfin, à l’intérieur de ce if déclaration, nous vérifions d’abord s’il y a une erreur ou si le résultat est finalisé. Si l’un de ces éléments est vrai, le moteur audio et les autres processus associés s’arrêteront et nous supprimerons le tap. Ne vous inquiétez pas, vous en apprendrez davantage sur les robinets à l’étape suivante!

sept. Démarrage du moteur audio

Enfin, le moment que vous attendiez! Nous pouvons enfin démarrer le moteur que nous avons passé si longtemps à créer. Nous allons faire cela en installant un « robinet ». Ajoutez le code suivant sous votre task initialisation:

let recordingFormat = inputNode.outputFormat(forBus: 0)
inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { (buffer, when) in
    self.request?.append(buffer)
}

Dans ce code, nous définissons le format de sortie du nœud d’entrée sur une constante appelée recordingFormat. Ceci est utilisé à l’étape suivante pour installer un audio tap sur le nœud d’entrée pour enregistrer et contrôler l’audio. À l’intérieur du gestionnaire de complétion, nous ajoutons le buffer au format PCM jusqu’à la fin de la demande de reconnaissance. Pour démarrer le moteur, ajoutez simplement les deux lignes de code suivantes:

audioEngine.prepare()
try? audioEngine.start()

Cela prépare simplement et tente ensuite de démarrer le moteur audio. Maintenant, nous devons appeler cette méthode à partir de notre bouton, alors faisons-le à l’étape suivante.

8. Désactivation et activation du bouton

Nous ne voulons pas que l’utilisateur puisse activer la reconnaissance vocale sauf si elle est disponible pour être utilisée. Sinon, l’application risque de planter. Nous pouvons le faire via une méthode déléguée, alors ajoutez les quelques lignes de code suivantes sous le startDictation() déclaration de méthode:

func speechRecognizer(_ speechRecognizer: SFSpeechRecognizer, availabilityDidChange available: Bool) {
    if available {
        dictationButton.isEnabled = true
    } else {
        dictationButton.isEnabled = false
    }
}

Il sera appelé lorsque la reconnaissance vocale sera disponible après avoir été indisponible ou indisponible après avoir été disponible. À l’intérieur, nous utiliserons simplement une instruction if pour activer ou désactiver le bouton en fonction de l’état de disponibilité.

Lorsque le bouton est désactivé, l’utilisateur ne voit rien, mais le bouton ne répond pas aux pressions. C’est une sorte de filet de sécurité pour empêcher l’utilisateur d’appuyer trop vite sur le bouton.

9. Répondre aux pressions sur les boutons

La dernière chose qui reste à faire est de répondre lorsque l’utilisateur appuie sur le bouton. Ici, nous pouvons également modifier ce que dit le bouton et dire à l’utilisateur ce qu’il doit faire. Pour vous rafraîchir la mémoire, voici le @IBAction nous avons fait plus tôt:

@IBAction func dictationButtonTapped() {
    // Your code goes here
}

À l’intérieur de cette fonction, ajoutez l’instruction if suivante:

if audioEngine.isRunning {
    dictationButton.setTitle("Start Recording", for: .normal)
    promptLabel.text = "Tap the button to dictate..."
    
    request?.endAudio()
    audioEngine.stop()
} else {
    dictationButton.setTitle("Stop Recording", for: .normal)
    promptLabel.text = "Go ahead. I'm listening..."
    
    startDictation()
}

Si le moteur audio est déjà en cours d’exécution, nous souhaitons arrêter la reconnaissance vocale et afficher l’invite appropriée à l’utilisateur. S’il ne fonctionne pas, nous devons lancer les options de reconnaissance et d’affichage pour que l’utilisateur arrête la dictée.

Conclusion

C’est ça! Vous avez créé une application qui peut reconnaître votre voix et la transcrire. Cela peut être utilisé pour une variété d’applications afin d’aider les utilisateurs qui ne peuvent pas interagir avec vos applications d’une autre manière. Si vous avez aimé ce tutoriel, assurez-vous de consulter les autres de cette série!

Et pendant que vous êtes ici, consultez quelques-uns de nos autres articles sur le développement d’applications Swift et iOS!