Forem: Andre Claudinei Barsotti

Reconhecimento de Voz no Android: Utilizando a lib android.speech

Andre Claudinei Barsotti — Sun, 21 Jan 2024 20:32:38 +0000

O processamento de língua falada, como tantos outros, é um capitulo interessante do Processamento de Linguagem Natural (PLN) e esta vinculado ao subcampo da Natural Languge Understand (NLU). Nesse processo busca-se basicamente fazer com que o dispositivo (computador, celular, etc.) seja capaz de "ouvir" e então transcrever o que foi falado em texto.

“O processamento da língua falada depende de uma vasta gama de conhecimentos que inclui acústica, fonologia, fonética, linguística geral, semântica, sintaxe, pragmática, estruturas discursivas, entre outras. Para além disso, outros conhecimentos mais comuns à ciência da computação, à engenharia elétrica, à matemática e, até mesmo à psicologia, também são necessários” (Caseli et al., 2023, p. 15)

Atualmente existem diversas bibliotecas que já nos fornecem a parte básica desse processo, sendo conhecidos como ASR Convencionais. Neles o resultado trata-se apenas de uma sequência de palavras, sem pontuações ou validações gramaticais, e que podem ser utilizados como base para outras aplicações.

Nesse artigo vamos explorar aspectos da implementação da biblioteca android.speech, nativa nos dispositivos Android e que trata-se exatamente de uma dessas ASR Convencionais. Não é nosso objetivo servir como tutorial, para essa finalidade sugerimos os artigos, em inglês, de Atitienei e Khare onde um passo-a-passo foi dado e que aplicamos em nosso aplicativo de exemplos que esta no GitHub.

Bibliotecas e permissões

Para incluir o STT (speech-to-text) em uma aplicação Android nenhuma biblioteca externa é necessária, porém é preciso que a aplicação tenha permissões para "gravar" audios. Dessa forma é preciso incluir a linha abaixo no manifesto da aplicação:

<uses-permission android:name="android.permission.RECORD_AUDIO" />

De forma complementar também será necessário solicitar a permissão de audio em algum momento o que pode ser feito da seguinte forma:

ActivityCompat.requestPermissions(
    context as Activity,
    arrayOf(Manifest.permission.RECORD_AUDIO),
    123
)

Reconhecendo a fala do usuário e convertendo em texto

Existem dois elementos básicos necessários para utilizar a função de texto para fala da biblioteca nativa do android:

SpeechRecognizer: Essa é a classe responsável por efetivamente executar a função de reconhecimento de voz.
RecognitionListener: Essa é uma interface onde os retornos das chamadas do reconhecimento de voz podem ser manipulados através de sua implementação em um objeto concreto.

O início do processo acontece quando uma instância do SpeechRecognizer é criada a partir do método estático factory da própria classe como no exemplo abaixo:

import android.speech.SpeechRecognizer

val recognizer = SpeechRecognizer.createSpeechRecognizer(context)

Nesse caso o contexto pode ser tanto a aplicação quanto a Activity, no nosso app de exemplo utilizamos como contexto a própria aplicação.

Com o recognizer criado vamos agora setar o listener, que será responsável por intermediar o que será reconhecido e tratar o texto resultante. Para setar utilize o método setRecognitionListener como no exemplo abaixo:

recognizer.setRecognitionListener(listener)

Agora será preciso definir uma Intent que irá iniciar nossa aplicação, esse intent passa para o SpeechRecognizer vários parâmetros que desejamos. Abaixo um exemplo:

import android.speech.RecognizerIntent

val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
    putExtra(
        RecognizerIntent.EXTRA_LANGUAGE_MODEL,
        RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
    )
    putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
    putExtra(RecognizerIntent.EXTRA_LANGUAGE, "pt-BR")
}

Nessa Intent informamos que nossa ação será de reconhecimento de voz (ACTION_RECOGNIZE_SPEECH), o extra EXTRA_LANGUAGE_MODEL é obrigatório pois precisamos definir o modelo de reconhecimento de falar que será utilizado, no nosso caso utilizamos o LANGUAGE_MODEL_FREE_FORM que indica um modelo de fala livre. Já o extra EXTRA_PARTIAL_RESULTS setado como true nos permite receber parciais do texto durante o reconhecimento da fala e o EXTRA_LANGUAGE com o valor pt-BR garante que haverá reconhecimento de voz para o português brasileiro. Mais detalhes sobre os parâmetros pode ser obtido na documentação do Intent.

Com esses passos feitos podemos iniciar o reconhecimento de voz chamando o método startListening passando nossa Intent como parâmetro:

recognizer.startListening(intent)

Para interromper basta chamar o método stopListening. Abaixo o exemplo:

recognizer.stopListening()

Como mencionado anteriormente os texto gerado pelo SpeechRecognizer é tratado em uma instância concreta da interface RecognitionListener, pois é nela que estão os eventos. Essa interface obriga a implementação dos seguintes métodos:

onReadyForSpeech: É chamado quando o SpeechRecognizer foi corretamente inicializado e esta pronto para processar a voz do usuário. Pode ser utilizado para indicar na interface com o usuário que ele pode começar a falar.
onBeginningOfSpeech: É chamado após o SpeechRecognizer identificar que o usuário começou a falar. Essa informação pode ser utilizada para indicar graficamente na interface que o usuário começou a falar.
onRmsChanged: Esse método recebe como um float (rmsdB) que indica uma métrica da variação do volume da fala durante o reconhecimento da voz. Pode ser utilizado para indicar graficamente na interface que a voz esta sendo reconhecida.
onEndOfSpeech: É chamado após o SpeechRecognizer identificar que o usuário terminou de falar. Essa informação pode ser utilizada para indicar graficamente na interface que o usuário terminou a falar.
onResults e onPartialResults: recebe um Bundle como parâmetro com o resultado do processamento total (onResults) ou parcial (onPartialResults), antes do usuário terminar de falar. É através desses métodos que o texto do que foi falados é gerado.
onError: Quando acontece algum erro no processamento da fala (fala irreconhecida, por exemplo) esse método será chamado e ele recebe um inteiro com o código do erro correspondente.
onBufferReceived: Recebe um buffer como um array de bytes que pode ser utilizado para salvar o audio gravado se for desejado.
onEvent: Esse método esta reservado para uso futuro e no momento não é chamado.

Mais detalhes sobre cada um dos callbacks pode ser encontrada na documentação. Podemos verificar que os métodos mais relevantes são o onResults e o onError, pois contemplam o texto transcrito do que foi falado ou o erro, caso aconteça algum problema. Abaixo um exemplo de implementação simples.

import android.speech.RecognitionListener
import android.widget.Toast

recognizer.setRecognitionListener(object:RecognitionListener {
    override fun onReadyForSpeech(params: Bundle?) = Unit

    override fun onBeginningOfSpeech() = Unit

    override fun onRmsChanged(rmsdB: Float) = Unit

    override fun onBufferReceived(buffer: ByteArray?) = Unit

    override fun onEndOfSpeech() = Unit

    override fun onError(error: Int) {
        val msgError = when (error) {
            SpeechRecognizer.ERROR_NETWORK_TIMEOUT -> "Network timeout"
            SpeechRecognizer.ERROR_NETWORK -> "Network error"
            SpeechRecognizer.ERROR_AUDIO -> "Audio recording error"
            SpeechRecognizer.ERROR_SERVER -> "Server error"
            SpeechRecognizer.ERROR_SPEECH_TIMEOUT -> "Speech input"
            SpeechRecognizer.ERROR_NO_MATCH -> "No recognition result matched."
            SpeechRecognizer.ERROR_RECOGNIZER_BUSY -> "RecognitionService busy"
            SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS -> "Insufficient permissions"
            else -> "Didn't understand, please try again."
        }

        Toast.makeText(context,"Error: $msgError", Toast.LENGTH_SHORT).show()
    }

    override fun onResults(results: Bundle?) {
        results
            ?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
            ?.getOrNull(0)
            ?.let { text ->
                Toast.makeText(context,"Text: $text", Toast.LENGTH_LONG).show()
            }
    }

    override fun onPartialResults(partialResults: Bundle?) = Unit

    override fun onEvent(eventType: Int, params: Bundle?) = Unit
})

Conclusões

A implementação do ASR em aplicações Android Nativas com a biblioteca nativa android.speech provou ser extremamente simplificada e prática, sem grandes complexidades no processo. Se o dispositivo estiver corretamente configurado em testes iniciais provou-se possível o seu uso offline, entende-se que seja necessário solicitar que o pacote de reconhecimento de fala padrão do assistente de voz local seja baixado para esse tipo de uso.

Tendo em vista sua facilidade e a ausência de pacotes adicionais entendem-se que trata-se de uma forma viável para o uso embarcado da tecnologia em aplicações Android Nativas.

Por ser um modelo convencional pode ser necessário algum tratamento do seu resultado conforme o uso desejado para o texto. Supondo, por exemplo, que seja desejado utilizá-lo para transcrições talvez seja necessário treinar um modelo para predição de pontuação para então utilizá-lo em uma aplicação produtiva, um exemplo da arquitetura esta na figura abaixo.

Um exemplo de prático aplicação dos conceitos aqui descritos pode ser encontrado no GitHub do autor. Esse aplicativo não dispõe ainda da habilidade de prever pontuação porém pode ser um ótimo ponto de partida, ele foi construído tomando como base o passo-a-passo descrito por Atitienei (2023) em seu artigo do Medium.

REFERÊNCIAS

ANDROID API REFERENCE: android.speech. [S. l.], [s. d.]. Disponível em: https://developer.android.com/reference/android/speech/package-summary. Acesso em: 12 jan. 2024.

ATITIENEI, D. Voice to Text in Jetpack Compose — Android. In: MEDIUM. 10 mar. 2023. Disponível em: https://medium.com/@daniel.atitienei/voice-to-text-in-jetpack-compose-android-c1e077627abe. Acesso em: 9 jan. 2024.

CASELI, H. M. (org.) et al. Processamento de Linguagem Natural: Conceitos, Técnicas e Aplicações em Português. 1. ed. In: Brasileiras em Processamento de Linguagem Natural. São Carlos: BPLN, 2023. E-Book. cap. 2 e cap.3 p. 15-63. Disponível em: https://brasileiraspln.com/livro-pln. Acesso em: 20 dez. 2023.

KHARE, A. Add Voice Commands to Android Apps. In: MEDIUM. GEEK CULTURE. 6 jul. 2021. Disponível em: https://medium.com/geekculture/add-voice-commands-to-android-apps-80157c0d5bcc. Acesso em: 9 jan. 2024.

Scripts em C#

Andre Claudinei Barsotti — Tue, 14 Sep 2021 12:56:21 +0000

Introdução

Scripts são uma ferramenta bem antiga nos ambientes de TI e ainda hoje são muito utilizados.

Sua natureza interpretada da à eles um dinamismo que supera em muito as facilidades de qualquer linguagem compilada.

JavaScript, com Node Js, e Python são exemplos que demonstram que a utilização de scripts no desenvolvimento de aplicações ainda segue em alta e sua força.

Estudando sobre Azure Functions me deparei com um arquivo a diferente extensão ".csx". Trata-se de um arquivo de scripts em linguagem C#, uma novidade para mim depois de vários anos trabalhando com essa linguagem.

Compartilho aqui com vocês o que aprendi sobre essa ferramenta e minhas conclusões.

Os scripts em C Sharp

Nos idos de 2011, Kirill Osenkov informou a comunidade .NET que a MS estava entregando o primeiro release preview do Roslyn Project. Nesse artigo, ele também informa que foi "introduzido o conceito de um arquivo de script C#" (OSENKOV, 2011). "A ideia principal por trás de escrever scripts em C# foi permitir que o código fosse avaliado dinamicamente pelo _runtime." (WOJ, 2015).

Para escrever um script C# você só precisa criar um arquivo com a extensão ".csx" em qualquer editor de textos. Depois de criar o arquivo você vai precisar de um programa para interpretá-lo. Hoje três opções:

Mono/Roslyn CSI (que já vem instalado com o Visual Studio);
cs-scripts;
dotnet-scripts.

O cs-scripts e dotnet-scripts são multiplataforma, e dotnet-scripts tem a vantagem ser instalado com um dotnet tool e rodar usando o .NET 5.

No restante desse artigo vamos utilizar o dotnet-scripts para nossos exemplos. Para instalá-lo digite o comando abaixo em seu console de preferência:

dotnet tool install -g dotnet-script

Sintaxe

"Um script C# tem requisitos de sintaxe mais flexíveis, então a experiência geral pode ser sem cerimônias. Abaixo estão algumas coisas a serem lembradas:

o ponto de entrada para o seu script é a primeira linha do seu arquivo (nenhum método Main obrigatório)

qualquer código é permitido a partir da primeira linha (nenhuma classe de nível superior, Program, obrigatória)

funções globais são permitidas;

sem namespaces;

sem um arquivo de projeto ou solução;

seu script pode ser totalmente autocontido;

instruções using e referências são importados implicitamente pelo aplicativo hospedeiro (responsável por executar o script)" (WOJCIESZYN, 2015)

Eu acrescento à essa lista o desenvolvimento de extensões, que foi algo que identifiquei nos meus testes.

Abaixo um exemplo de arquivo de script C# utilizado para inicializar o processo:

#load "Configs.csx"
#load "src/Data/TodoListRepository.csx"
#load "src/Services/TodoListService.csx"
#load "src/Controller/TodoListController.csx"
using Microsoft.Extensions.Configuration;

await Run(Args.ToArray());

async Task Run(string[] args)
{
    using TodoListRepository repository = new(Configs.Configuration.GetConnectionString("db"));
    TodoListService service = new(repository);
    TodoListController controller = new(service);
    await controller.ExecuteCommand(args);
}

Como pode ser visto a sintaxe da linguagem é a mesma já conhecida, só que sem a estrutura Program.Main. A forma de referenciar outros arquivos ".csx" é utilizando a diretiva #load "<caminho do arquivo>".

Abaixo um exemplo de arquivo para leitura de configurações, que faz referência à pacotes nuget:

#r "nuget: Microsoft.Extensions.Configuration, 5.0.0"
#r "nuget: Microsoft.Extensions.Configuration.Binder, 5.0.0"
#r "nuget: Microsoft.Extensions.Configuration.UserSecrets, 5.0.0"
#r "nuget: Microsoft.Extensions.Configuration.EnvironmentVariables, 5.0.0"

using Microsoft.Extensions.Configuration;

public static class Configs
{
    private static IConfiguration _config;

    public static IConfiguration Configuration 
    {
        get 
        {
            if (_config is null)
                SetConfig();

            return _config;
        }
    }

    private static void SetConfig()
    {
        _config = new ConfigurationBuilder()
                        .SetBasePath(Directory.GetCurrentDirectory())
                        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                        .AddUserSecrets("csx-script-app")
                        .AddEnvironmentVariables()
                        .Build();
    }

    public static T GetConfig<T>(string sectionName)
    {
        return Configuration.GetSection(sectionName).Get<T>();
    }
}

Referenciar um pacote é bem simples utilizando #r "nuget: <nome do pacote>, <versão>".

Se for necessário importar um assembly próprio é utilize a direntiva #r "<caminho da dll>". Segue um exemplo:

#r: "./build/MeuAssembly.dll"

Desenvolvi um aplicativo Todo de exemplo e publiquei no meu GitHub onde é possível ver esses scripts em ação. Esse é o link do projeto.

Debug

Se você utiliza o Visual Studio Code como seu editor de texto/IDE debugar um script é algo que seguirá os padrões que você já esta acostumado. Basta configurar seu launch.json conforme abaixo, colocar o breakpoint e clicar em F5.

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": ".NET Script Debug - Linux",
      "type": "coreclr",
      "request": "launch",
      "program": "${env:HOME}/.dotnet/tools/dotnet-script",
      "args": [
        "${file}"
      ],
      "cwd": "${workspaceFolder}",
      "stopAtEntry": false,
    },
    {
      "name": ".NET Script Debug - Windows",
      "type": "coreclr",
      "request": "launch",
      "program": "dotnet",
      "args": [
          "${env:USERPROFILE}/.dotnet/tools/.store/dotnet-script/1.2.1/dotnet-script/1.2.1/tools/net5.0/any/dotnet-script.dll",
          "${file}"
      ],
      "cwd": "${workspaceRoot}",
      "stopAtEntry": false
    }
  ]
}

Compilação com um aplicativo e execução no Linux.

Um ponto interessante que achei utilizando o dotnet-script no Windows foi a possibilidade de criar um aplicativo autocontido. Para fazer isso é muito simples basta publicar o script como no exemplo abaixo:

dotnet script publish Main.csx

Um diretório publish será criado com um executável. Como é um aplicativo autocontido, basta copiá-lo para qualquer computador e, mesmo sem o .NET instalado, executá-lo.

Em um ambiente Linux incluindo como primeira linha a diretiva #!/usr/bin/env dotnet-script é possível executar o script como qualquer outro, lembrando que é preciso dar permissão de execução no arquivo.

Conclusão e aplicações

Observando a tecnologia vemos que essa ferramenta é bem madura e que vem se desenvolvendo junto com a plataforma e que irá continuar nesse caminho no futuro.

Hoje é possível escrever um programa console em C# de forma minimalista sem uma classe Program, um método Main e com funções globais, algo que até pouco tempo atrás era impensável. Com scripts C# você consegue tudo isso e ainda a vantagem de desenvolver sem um ".csproj" e sem o tempo de compilação, apenas escrever o código e já validar seu programa prontamente.

Testes de integração que serão executados sob demanda; programas de carga que serão utilizados apenas uma vez; pequenos testes e estudos de algum pacote Nuget novo; Scripts de configuração de ambiente. Esses são apenas alguns exemplos de utilização de scripts em C#.

No caso de scripts para configuração de ambiente ou inicialização de uma aplicativo, ainda existe a vantagem latente de seguir com a mesma linguagem que o projeto foi desenvolvido. Para a equipe isso é uma vantagem, visto que é preciso um esforço adicional para aprender e escrever o mesmo script com um bash script ou bat tradicional.

Em programas de carga existe ainda a vantagem de conseguir reaproveitar o código e as regras de negócio do próprio projeto, sem duplicidades.

As aplicações são muitas e certamente vale a pena incluir no "arsenal".

Referências

BAHRAMINEZHAD, Ali. Hitchhiker’s Guide to the C# scripting. ITNEXT, 2019. Disponível em: <https://itnext.io/hitchhikers-guide-to-the-c-scripting-13e45f753af9>. Acesso em: 11-09-2021

MICHAELIS, Mark. C# Scripting. Microsotf Docs, 2016. Disponível em: <https://docs.microsoft.com/en-us/archive/msdn-magazine/2016/january/essential-net-csharp-scripting>. Acesso em: 11-09-2021

OSENKOV, Kirill. Introducing the Microsoft “Roslyn” CTP. Microsoft DevBlogs, 2011. Disponível em <https://devblogs.microsoft.com/visualstudio/introducing-the-microsoft-roslyn-ctp/>. Acesso em: 12-09-2021

SALVADEO, André C B. Todo List em C# script (CSX). Github, 2021. Disponível em <https://github.com/andrebarsotti/csx-script-sample>. Acesso em: 12-09-2021

VOGEL, Peter. Making Your Life Easier with C# Scripting. Visual Studio Magazine, 2021. Disponível em: <https://visualstudiomagazine.com/articles/2021/06/14/csharp-scripting.aspx>. Acesso em: 11-09-2021

WOJCIESZYN, Filip. Dotnet script. Github, 2021. Disponível em <https://github.com/filipw/dotnet-script>. Acesso em: 11-09-2021

WOJCIESZYN, Filip. Adding C# scripting to your development arsenal - Part 1. Microsoft Docs - Blog Archive - Canadian Developer Connection, 2015. Disponível em <https://docs.microsoft.com/pt-br/archive/blogs/cdndevs/adding-c-scripting-to-your-development-arsenal-part-1>. Acesso em: 12-09-2021