Reconhecimento de fala usando o Serviço de Fala do Azure

O Serviço de Fala do Azure é uma API baseada em nuvem que oferece a seguinte funcionalidade:

• A conversão de fala em texto transcreve arquivos de áudio ou fluxos para texto.
• A conversão de texto em fala converte o texto de entrada em fala sintetizada semelhante à humana.
• A tradução de fala permite a tradução em tempo real e multilíngue para fala para texto e fala para fala.
• Os assistentes de voz podem criar interfaces de conversação semelhantes às humanas para aplicativos.

Este artigo explica como a conversão de fala em texto é implementada no aplicativo de exemplo Xamarin.Forms usando o Serviço de Fala do Azure. As capturas de tela a seguir mostram o aplicativo de exemplo no iOS e no Android:

Criar um recurso do Serviço de Fala do Azure

O Serviço de Fala do Azure faz parte dos Serviços Cognitivos do Azure, que fornece APIs baseadas em nuvem para tarefas como reconhecimento de imagem, reconhecimento e tradução de fala e pesquisa do Bing. Para obter mais informações, consulte O que são os Serviços Cognitivos do Azure?.

O projeto de exemplo requer que um recurso dos Serviços Cognitivos do Azure seja criado em seu portal do Azure. Um recurso dos Serviços Cognitivos pode ser criado para um único serviço, como o Serviço de Fala, ou como um recurso de vários serviços. As etapas para criar um recurso do Serviço de Fala são as seguintes:

1. Faça logon no portal do Azure.
2. Crie um recurso de vários serviços ou de serviço único.
3. Obtenha a chave de API e as informações de região do seu recurso.
4. Atualize o arquivo Constants.cs de amostra.

Para obter um guia passo a passo para criar um recurso, consulte Criar um recurso dos Serviços Cognitivos.

Configurar seu aplicativo com o Serviço de Fala

Depois de criar um recurso dos Serviços Cognitivos, o arquivo Constants.cs pode ser atualizado com a região e a chave de API do recurso do Azure:

public static class Constants
{
    public static string CognitiveServicesApiKey = "YOUR_KEY_GOES_HERE";
    public static string CognitiveServicesRegion = "westus";
}

Instalar o pacote do Serviço de Fala do NuGet

O aplicativo de exemplo usa o pacote NuGet Microsoft.CognitiveServices.Speech para se conectar ao Serviço de Fala do Azure. Instale esse pacote NuGet no projeto compartilhado e em cada projeto de plataforma.

Criar uma interface IMicrophoneService

Cada plataforma requer permissão para acessar o microfone. O projeto de exemplo fornece uma IMicrophoneService interface no projeto compartilhado e usa o Xamarin.FormsDependencyService para obter implementações de plataforma da interface.

public interface IMicrophoneService
{
    Task<bool> GetPermissionAsync();
    void OnRequestPermissionResult(bool isGranted);
}

Criar o layout da página

O projeto de exemplo define um layout de página básico no arquivo MainPage.xaml . Os principais elementos de layout são um Button que inicia o processo de transcrição, um Label para conter o texto transcrito e um ActivityIndicator para mostrar quando a transcrição está em andamento:

<ContentPage ...>
    <StackLayout>
        <Frame ...>
            <ScrollView x:Name="scroll"
                        ...>
                <Label x:Name="transcribedText"
                       ... />
            </ScrollView>
        </Frame>

        <ActivityIndicator x:Name="transcribingIndicator"
                           IsRunning="False" />
        <Button x:Name="transcribeButton"
                ...
                Clicked="TranscribeClicked"/>
    </StackLayout>
</ContentPage>

Implementar o Serviço de Fala

O arquivo code-behind MainPage.xaml.cs contém toda a lógica para enviar áudio e receber texto transcrito do Serviço de Fala do Azure.

O MainPage construtor obtém uma instância da IMicrophoneService interface do DependencyService:

public partial class MainPage : ContentPage
{
    SpeechRecognizer recognizer;
    IMicrophoneService micService;
    bool isTranscribing = false;

    public MainPage()
    {
        InitializeComponent();

        micService = DependencyService.Resolve<IMicrophoneService>();
    }

    // ...
}

O TranscribeClicked método é chamado quando a transcribeButton instância é tocada:

async void TranscribeClicked(object sender, EventArgs e)
{
    bool isMicEnabled = await micService.GetPermissionAsync();

    // EARLY OUT: make sure mic is accessible
    if (!isMicEnabled)
    {
        UpdateTranscription("Please grant access to the microphone!");
        return;
    }

    // initialize speech recognizer
    if (recognizer == null)
    {
        var config = SpeechConfig.FromSubscription(Constants.CognitiveServicesApiKey, Constants.CognitiveServicesRegion);
        recognizer = new SpeechRecognizer(config);
        recognizer.Recognized += (obj, args) =>
        {
            UpdateTranscription(args.Result.Text);
        };
    }

    // if already transcribing, stop speech recognizer
    if (isTranscribing)
    {
        try
        {
            await recognizer.StopContinuousRecognitionAsync();
        }
        catch(Exception ex)
        {
            UpdateTranscription(ex.Message);
        }
        isTranscribing = false;
    }

    // if not transcribing, start speech recognizer
    else
    {
        Device.BeginInvokeOnMainThread(() =>
        {
            InsertDateTimeRecord();
        });
        try
        {
            await recognizer.StartContinuousRecognitionAsync();
        }
        catch(Exception ex)
        {
            UpdateTranscription(ex.Message);
        }
        isTranscribing = true;
    }
    UpdateDisplayState();
}

O método TranscribeClicked faz o seguinte:

1. Verifica se o aplicativo tem acesso ao microfone e sai mais cedo se não tiver.
2. Cria uma instância de SpeechRecognizer classe se ela ainda não existir.
3. Interrompe a transcrição contínua se estiver em andamento.
4. Insere um carimbo de data/hora e inicia a transcrição contínua se ela não estiver em andamento.
5. Notifica o aplicativo para atualizar sua aparência com base no novo estado do aplicativo.

O restante dos métodos de MainPage classe são auxiliares para exibir o estado do aplicativo:

void UpdateTranscription(string newText)
{
    Device.BeginInvokeOnMainThread(() =>
    {
        if (!string.IsNullOrWhiteSpace(newText))
        {
            transcribedText.Text += $"{newText}\n";
        }
    });
}

void InsertDateTimeRecord()
{
    var msg = $"=================\n{DateTime.Now.ToString()}\n=================";
    UpdateTranscription(msg);
}

void UpdateDisplayState()
{
    Device.BeginInvokeOnMainThread(() =>
    {
        if (isTranscribing)
        {
            transcribeButton.Text = "Stop";
            transcribeButton.BackgroundColor = Color.Red;
            transcribingIndicator.IsRunning = true;
        }
        else
        {
            transcribeButton.Text = "Transcribe";
            transcribeButton.BackgroundColor = Color.Green;
            transcribingIndicator.IsRunning = false;
        }
    });
}

O UpdateTranscription método grava Label o fornecido newText string no elemento chamado transcribedText. Isso força essa atualização a acontecer no thread da interface do usuário para que possa ser chamada de qualquer contexto sem causar exceções. O grava InsertDateTimeRecord a data e a hora atuais na transcribedText instância para marcar o início de uma nova transcrição. Por fim, o UpdateDisplayState método atualiza os elementos e ActivityIndicator para refletir se a Button transcrição está ou não em andamento.

Criar serviços de microfone de plataforma

O aplicativo deve ter acesso ao microfone para coletar dados de fala. A IMicrophoneService interface deve ser implementada DependencyService e registrada no em cada plataforma para que o aplicativo funcione.

Android

O projeto de exemplo define uma IMicrophoneService implementação para Android chamada AndroidMicrophoneService:

[assembly: Dependency(typeof(AndroidMicrophoneService))]
namespace CognitiveSpeechService.Droid.Services
{
    public class AndroidMicrophoneService : IMicrophoneService
    {
        public const int RecordAudioPermissionCode = 1;
        private TaskCompletionSource<bool> tcsPermissions;
        string[] permissions = new string[] { Manifest.Permission.RecordAudio };

        public Task<bool> GetPermissionAsync()
        {
            tcsPermissions = new TaskCompletionSource<bool>();

            if ((int)Build.VERSION.SdkInt < 23)
            {
                tcsPermissions.TrySetResult(true);
            }
            else
            {
                var currentActivity = MainActivity.Instance;
                if (ActivityCompat.CheckSelfPermission(currentActivity, Manifest.Permission.RecordAudio) != (int)Permission.Granted)
                {
                    RequestMicPermissions();
                }
                else
                {
                    tcsPermissions.TrySetResult(true);
                }

            }

            return tcsPermissions.Task;
        }

        public void OnRequestPermissionResult(bool isGranted)
        {
            tcsPermissions.TrySetResult(isGranted);
        }

        void RequestMicPermissions()
        {
            if (ActivityCompat.ShouldShowRequestPermissionRationale(MainActivity.Instance, Manifest.Permission.RecordAudio))
            {
                Snackbar.Make(MainActivity.Instance.FindViewById(Android.Resource.Id.Content),
                        "Microphone permissions are required for speech transcription!",
                        Snackbar.LengthIndefinite)
                        .SetAction("Ok", v =>
                        {
                            ((Activity)MainActivity.Instance).RequestPermissions(permissions, RecordAudioPermissionCode);
                        })
                        .Show();
            }
            else
            {
                ActivityCompat.RequestPermissions((Activity)MainActivity.Instance, permissions, RecordAudioPermissionCode);
            }
        }
    }
}

O tem AndroidMicrophoneService as seguintes características:

1. O Dependency atributo registra a classe com o DependencyService.
2. O GetPermissionAsync método verifica se as permissões são necessárias com base na versão do SDK do Android e chama RequestMicPermissions se a permissão ainda não foi concedida.
3. O RequestMicPermissions método usa a Snackbar classe para solicitar permissões do usuário se uma justificativa for necessária, caso contrário, ele solicitará diretamente permissões de gravação de áudio.
4. O OnRequestPermissionResult método é chamado com um bool resultado quando o usuário responde à solicitação de permissões.

A MainActivity classe é personalizada para atualizar a instância quando as AndroidMicrophoneService solicitações de permissões são concluídas:

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
{
    IMicrophoneService micService;
    internal static MainActivity Instance { get; private set; }

    protected override void OnCreate(Bundle savedInstanceState)
    {
        Instance = this;
        // ...
        micService = DependencyService.Resolve<IMicrophoneService>();
    }
    public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
    {
        // ...
        switch(requestCode)
        {
            case AndroidMicrophoneService.RecordAudioPermissionCode:
                if (grantResults[0] == Permission.Granted)
                {
                    micService.OnRequestPermissionResult(true);
                }
                else
                {
                    micService.OnRequestPermissionResult(false);
                }
                break;
        }
    }
}

A MainActivity classe define uma referência estática chamada Instance, que é exigida AndroidMicrophoneService pelo objeto ao solicitar permissões. Ele substitui o OnRequestPermissionsResult método para atualizar o AndroidMicrophoneService objeto quando a solicitação de permissões é aprovada ou negada pelo usuário.

Por fim, o aplicativo Android deve incluir a permissão para gravar áudio no arquivo AndroidManifest.xml :

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

iOS

O projeto de exemplo define uma IMicrophoneService implementação para iOS chamada iOSMicrophoneService:

[assembly: Dependency(typeof(iOSMicrophoneService))]
namespace CognitiveSpeechService.iOS.Services
{
    public class iOSMicrophoneService : IMicrophoneService
    {
        TaskCompletionSource<bool> tcsPermissions;

        public Task<bool> GetPermissionAsync()
        {
            tcsPermissions = new TaskCompletionSource<bool>();
            RequestMicPermission();
            return tcsPermissions.Task;
        }

        public void OnRequestPermissionResult(bool isGranted)
        {
            tcsPermissions.TrySetResult(isGranted);
        }

        void RequestMicPermission()
        {
            var session = AVAudioSession.SharedInstance();
            session.RequestRecordPermission((granted) =>
            {
                tcsPermissions.TrySetResult(granted);
            });
        }
    }
}

O tem iOSMicrophoneService as seguintes características:

1. O Dependency atributo registra a classe com o DependencyService.
2. O GetPermissionAsync método chama RequestMicPermissions para solicitar permissões do usuário do dispositivo.
3. O RequestMicPermissions método usa a instância compartilhada AVAudioSession para solicitar permissões de gravação.
4. O OnRequestPermissionResult método atualiza a TaskCompletionSource instância com o valor fornecido bool .

Por fim, o aplicativo iOS Info.plist deve incluir uma mensagem que informe ao usuário por que o aplicativo está solicitando acesso ao microfone. Edite o arquivo Info.plist para incluir as seguintes marcas no <dict> elemento:

<plist>
    <dict>
        ...
        <key>NSMicrophoneUsageDescription</key>
        <string>Voice transcription requires microphone access</string>
    </dict>
</plist>

UWP

O projeto de exemplo define uma IMicrophoneService implementação para UWP chamada UWPMicrophoneService:

[assembly: Dependency(typeof(UWPMicrophoneService))]
namespace CognitiveSpeechService.UWP.Services
{
    public class UWPMicrophoneService : IMicrophoneService
    {
        public async Task<bool> GetPermissionAsync()
        {
            bool isMicAvailable = true;
            try
            {
                var mediaCapture = new MediaCapture();
                var settings = new MediaCaptureInitializationSettings();
                settings.StreamingCaptureMode = StreamingCaptureMode.Audio;
                await mediaCapture.InitializeAsync(settings);
            }
            catch(Exception ex)
            {
                isMicAvailable = false;
            }

            if(!isMicAvailable)
            {
                await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-microphone"));
            }

            return isMicAvailable;
        }

        public void OnRequestPermissionResult(bool isGranted)
        {
            // intentionally does nothing
        }
    }
}

O tem UWPMicrophoneService as seguintes características:

1. O Dependency atributo registra a classe com o DependencyService.
2. O GetPermissionAsync método tenta inicializar uma MediaCapture instância. Se isso falhar, ele iniciará uma solicitação do usuário para ativar o microfone.
3. O OnRequestPermissionResult método existe para satisfazer a interface, mas não é necessário para a implementação da UWP.

Por fim, o Package.appxmanifest UWP deve especificar que o aplicativo usa o microfone. Clique duas vezes no arquivo Package.appxmanifest e selecione a opção Microfone na guia Recursos no Visual Studio 2019:

Testar o aplicativo

Execute o aplicativo e clique no botão Transcrever . O aplicativo deve solicitar acesso ao microfone e iniciar o processo de transcrição. O ActivityIndicator será animado, mostrando que a transcrição está ativa. Enquanto você fala, o aplicativo transmitirá dados de áudio para o recurso dos Serviços de Fala do Azure, que responderá com texto transcrito. O texto transcrito aparecerá no elemento à medida que Label for recebido.

Links relacionados

• Visão geral do Serviço de Fala do Azure
• Criar um recurso dos Serviços Cognitivos
• Início Rápido: Reconhecer fala de um microfone