Quickstart: Recognize speech from a microphone

Prerequisites

Before you get started:

Open your project in Visual Studio

The first step is to make sure that you have your project open in Visual Studio.

1. Launch Visual Studio 2019.
2. Load your project and open Program.cs.

Source code

Replace the contents of the Program.cs file with the following C# code.

using System;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;

namespace Speech.Recognition
{
    class Program
    {
        static async Task Main()
        {
            await RecognizeSpeechAsync();

            Console.WriteLine("Please press any key to continue...");
            Console.ReadLine();
        }

        static async Task RecognizeSpeechAsync()
        {
            var config =
                SpeechConfig.FromSubscription(
                    "YourSubscriptionKey",
                    "YourServiceRegion");

            using var recognizer = new SpeechRecognizer(config);
            
            var result = await recognizer.RecognizeOnceAsync();
            switch (result.Reason)
            {
                case ResultReason.RecognizedSpeech:
                    Console.WriteLine($"We recognized: {result.Text}");
                    break;
                case ResultReason.NoMatch:
                    Console.WriteLine($"NOMATCH: Speech could not be recognized.");
                    break;
                case ResultReason.Canceled:
                    var cancellation = CancellationDetails.FromResult(result);
                    Console.WriteLine($"CANCELED: Reason={cancellation.Reason}");
    
                    if (cancellation.Reason == CancellationReason.Error)
                    {
                        Console.WriteLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
                        Console.WriteLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
                        Console.WriteLine($"CANCELED: Did you update the subscription info?");
                    }
                    break;
            }
        }
    }
}

Replace the YourSubscriptionKey and YourServiceRegion values with actual values from the Speech resource.

• Navigate to the Azure portal , and open the Speech resource
• Under the Keys on the left, there are two available subscription keys
  • Use either one as the YourSubscriptionKey value replacement
• Under the Overview on the left, note the region and map it to the region identifier
  • Use the Region identifier as the YourServiceRegion value replacement, for example: "westus" for West US

Code explanation

The Speech resource subscription key and region are required to create a speech configuration object. The configuration object is needed to instantiate a speech recognizer object.

The recognizer instance exposes multiple ways to recognize speech. In this example, speech is recognized once. This functionality lets the Speech service know that you're sending a single phrase for recognition, and that once the phrase is identified to stop recognizing speech. Once the result is yielded, the code will write the recognition reason to the console.

Build and run app

Now you're ready to rebuild your app and test the speech recognition functionality using the Speech service.

1. Compile the code - From the menu bar of Visual Studio, choose Build > Build Solution.
2. Start your app - From the menu bar, choose Debug > Start Debugging or press F5.
3. Start recognition - It will prompt you to speak a phrase in English. Your speech is sent to the Speech service, transcribed as text, and rendered in the console.

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

If you've already done this, great. Let's keep going.

Create a Unity project

1. Open Unity. If you're using Unity for the first time, the Unity Hub window appears. (You can also open Unity Hub directly to get to this window.)

   

2. Select New. The Create a new project with Unity window appears.

   

3. In Project Name, enter csharp-unity.

4. In Templates, if 3D isn't already selected, select it.

5. In Location, select or create a folder to save the project in.

6. Select Create.

After a bit of time, the Unity Editor window appears.

Add UI

Now let's add a minimal UI to our scene. This UI consists of a button to trigger speech recognition and a text field to display the result. In the Hierarchy window, a sample scene is shown that Unity created with the new project.

1. At the top of the Hierarchy window, select Create > UI > Button.

   This action creates three game objects that you can see in the Hierarchy window: a Button object, a Canvas object containing the button, and an EventSystem object.

   

2. Navigate the Scene view so you have a good view of the canvas and the button in the Scene view.

3. In the Inspector window (by default on the right), set the Pos X and Pos Y properties to 0, so the button is centered in the middle of the canvas.

4. In the Hierarchy window, select Create > UI > Text to create a Text object.

5. In the Inspector window, set the Pos X and Pos Y properties to 0 and 120, and set the Width and Height properties to 240 and 120. These values ensure that the text field and the button don't overlap.

When you're done, the Scene view should look similar to this screenshot:

Add the sample code

To add the sample script code for the Unity project, follow these steps:

1. In the Project window, select Create > C# script to add a new C# script.

   

2. Name the script HelloWorld.

3. Double-click HelloWorld to edit the newly created script.

   Note

   To configure the code editor to be used by Unity for editing, select Edit > Preferences, and then go to the External Tools preferences. For more information, see the Unity User Manual.

4. Replace the existing script with the following code:

   using UnityEngine;
   using UnityEngine.UI;
   using Microsoft.CognitiveServices.Speech;
   #if PLATFORM_ANDROID
   using UnityEngine.Android;
   #endif
   #if PLATFORM_IOS
   using UnityEngine.iOS;
   using System.Collections;
   #endif
   
   public class HelloWorld : MonoBehaviour
   {
       // Hook up the two properties below with a Text and Button object in your UI.
       public Text outputText;
       public Button startRecoButton;
   
       private object threadLocker = new object();
       private bool waitingForReco;
       private string message;
   
       private bool micPermissionGranted = false;
   
   #if PLATFORM_ANDROID || PLATFORM_IOS
       // Required to manifest microphone permission, cf.
       // https://docs.unity3d.com/Manual/android-manifest.html
       private Microphone mic;
   #endif
   
       public async void ButtonClick()
       {
           // Creates an instance of a speech config with specified subscription key and service region.
           // Replace with your own subscription key and service region (e.g., "westus").
           var config = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
   
           // Make sure to dispose the recognizer after use!
           using (var recognizer = new SpeechRecognizer(config))
           {
               lock (threadLocker)
               {
                   waitingForReco = true;
               }
   
               // Starts speech recognition, and returns after a single utterance is recognized. The end of a
               // single utterance is determined by listening for silence at the end or until a maximum of 15
               // seconds of audio is processed.  The task returns the recognition text as result.
               // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
               // shot recognition like command or query.
               // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
               var result = await recognizer.RecognizeOnceAsync().ConfigureAwait(false);
   
               // Checks result.
               string newMessage = string.Empty;
               if (result.Reason == ResultReason.RecognizedSpeech)
               {
                   newMessage = result.Text;
               }
               else if (result.Reason == ResultReason.NoMatch)
               {
                   newMessage = "NOMATCH: Speech could not be recognized.";
               }
               else if (result.Reason == ResultReason.Canceled)
               {
                   var cancellation = CancellationDetails.FromResult(result);
                   newMessage = $"CANCELED: Reason={cancellation.Reason} ErrorDetails={cancellation.ErrorDetails}";
               }
   
               lock (threadLocker)
               {
                   message = newMessage;
                   waitingForReco = false;
               }
           }
       }
   
       void Start()
       {
           if (outputText == null)
           {
               UnityEngine.Debug.LogError("outputText property is null! Assign a UI Text element to it.");
           }
           else if (startRecoButton == null)
           {
               message = "startRecoButton property is null! Assign a UI Button to it.";
               UnityEngine.Debug.LogError(message);
           }
           else
           {
               // Continue with normal initialization, Text and Button objects are present.
   #if PLATFORM_ANDROID
               // Request to use the microphone, cf.
               // https://docs.unity3d.com/Manual/android-RequestingPermissions.html
               message = "Waiting for mic permission";
               if (!Permission.HasUserAuthorizedPermission(Permission.Microphone))
               {
                   Permission.RequestUserPermission(Permission.Microphone);
               }
   #elif PLATFORM_IOS
               if (!Application.HasUserAuthorization(UserAuthorization.Microphone))
               {
                   Application.RequestUserAuthorization(UserAuthorization.Microphone);
               }
   #else
               micPermissionGranted = true;
               message = "Click button to recognize speech";
   #endif
               startRecoButton.onClick.AddListener(ButtonClick);
           }
       }
   
       void Update()
       {
   #if PLATFORM_ANDROID
           if (!micPermissionGranted && Permission.HasUserAuthorizedPermission(Permission.Microphone))
           {
               micPermissionGranted = true;
               message = "Click button to recognize speech";
           }
   #elif PLATFORM_IOS
           if (!micPermissionGranted && Application.HasUserAuthorization(UserAuthorization.Microphone))
           {
               micPermissionGranted = true;
               message = "Click button to recognize speech";
           }
   #endif
   
           lock (threadLocker)
           {
               if (startRecoButton != null)
               {
                   startRecoButton.interactable = !waitingForReco && micPermissionGranted;
               }
               if (outputText != null)
               {
                   outputText.text = message;
               }
           }
       }
   }
   

5. Find and replace the string YourSubscriptionKey with your Speech service subscription key.

6. Find and replace the string YourServiceRegion with the Region identifier from region associated with your subscription. For example, if you're using the free trial, the region is westus.

7. Save the changes to the script.

Now return to the Unity Editor and add the script as a component to one of your game objects:

1. In the Hierarchy window, select the Canvas object.

2. In the Inspector window, select the Add Component button.

   

3. In the drop-down list, search for the HelloWorld script we created above and add it. A Hello World (Script) section appears in the Inspector window, listing two uninitialized properties, Output Text and Start Reco Button. These Unity component properties match public properties of the HelloWorld class.

4. Select the Start Reco Button property's object picker (the small circle icon to the right of the property), and choose the Button object you created earlier.

5. Select the Output Text property's object picker, and choose the Text object you created earlier.

   Note

   The button also has a nested text object. Make sure you do not accidentally pick it for text output (or rename one of the text objects using the Name field in the Inspector window to avoid confusion).

Run the application in the Unity Editor

Now you're ready to run the application within the Unity Editor.

1. In the Unity Editor toolbar (below the menu bar), select the Play button (a right-pointing triangle).

2. Go to Game view, and wait for the Text object to display Click button to recognize speech. (It displays New Text when the application hasn't started or isn't ready to respond.)

3. Select the button and speak an English phrase or sentence into your computer's microphone. Your speech is transmitted to the Speech service and transcribed to text, which appears in the Game view.

   

4. Check the Console window for debug messages. If the Console window isn't showing, go to the menu bar and select Window > General > Console to display it.

5. When you're done recognizing speech, select the Play button in the Unity Editor toolbar to stop the application.

Additional options to run this application

This application can also be deployed to as an Android app, a Windows stand-alone app, or a UWP application. For more information, see our sample repository. The quickstart/csharp-unity folder describes the configuration for these additional targets.

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

If you've already done this, great. Let's keep going.

Open your project in Visual Studio

The first step is to make sure that you have your project open in Visual Studio.

Start with some boilerplate code

Let's add some code that works as a skeleton for our project.

1. In Solution Explorer, open MainPage.xaml.

2. In the designer's XAML view, insert the following XAML snippet into the Grid tag (between <Grid> and </Grid>):

   <StackPanel Orientation="Vertical" HorizontalAlignment="Center"  Margin="20,50,0,0" VerticalAlignment="Center" Width="800">
       <Button x:Name="EnableMicrophoneButton" Content="Enable Microphone"  Margin="0,0,10,0" Click="EnableMicrophone_ButtonClicked" Height="35"/>
       <Button x:Name="SpeechRecognitionButton" Content="Speech recognition with microphone input" Margin="0,10,10,0" Click="SpeechRecognitionFromMicrophone_ButtonClicked" Height="35"/>
       <StackPanel x:Name="StatusPanel" Orientation="Vertical" RelativePanel.AlignBottomWithPanel="True" RelativePanel.AlignRightWithPanel="True" RelativePanel.AlignLeftWithPanel="True">
           <TextBlock x:Name="StatusLabel" Margin="0,10,10,0" TextWrapping="Wrap" Text="Status:" FontSize="20"/>
           <Border x:Name="StatusBorder" Margin="0,0,0,0">
               <ScrollViewer VerticalScrollMode="Auto"  VerticalScrollBarVisibility="Auto" MaxHeight="200">
                   <!-- Use LiveSetting to enable screen readers to announce the status update. -->
                   <TextBlock x:Name="StatusBlock" FontWeight="Bold" AutomationProperties.LiveSetting="Assertive"
                   MaxWidth="{Binding ElementName=Splitter, Path=ActualWidth}" Margin="10,10,10,20" TextWrapping="Wrap"  />
               </ScrollViewer>
           </Border>
       </StackPanel>
   </StackPanel>
   

3. In Solution Explorer, open the code-behind source file MainPage.xaml.cs. (It's grouped under MainPage.xaml.)

4. Replace the code with the following base code:

   using System;
   using System.Text;
   using Windows.UI.Xaml;
   using Windows.UI.Xaml.Controls;
   using Windows.UI.Xaml.Media;
   using Microsoft.CognitiveServices.Speech;
   
   namespace helloworld
   {
       /// <summary>
       /// An empty page that can be used on its own or navigated to within a Frame.
       /// </summary>
       public sealed partial class MainPage : Page
       {
           public MainPage()
           {
               this.InitializeComponent();
           }
   
           private async void EnableMicrophone_ButtonClicked(object sender, RoutedEventArgs e)
           {
               bool isMicAvailable = true;
               try
               {
                   var mediaCapture = new Windows.Media.Capture.MediaCapture();
                   var settings = new Windows.Media.Capture.MediaCaptureInitializationSettings();
                   settings.StreamingCaptureMode = Windows.Media.Capture.StreamingCaptureMode.Audio;
                   await mediaCapture.InitializeAsync(settings);
               }
               catch (Exception)
               {
                   isMicAvailable = false;
               }
               if (!isMicAvailable)
               {
                   await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-microphone"));
               }
               else
               {
                   NotifyUser("Microphone was enabled", NotifyType.StatusMessage);
               }
           }
   
           private async void SpeechRecognitionFromMicrophone_ButtonClicked(object sender, RoutedEventArgs e)
           {
               try
               {
               }
               catch(Exception ex)
               {
                   NotifyUser($"Enable Microphone First.\n {ex.ToString()}", NotifyType.ErrorMessage);
               }
           }
   
           private enum NotifyType
           {
               StatusMessage,
               ErrorMessage
           };
   
           private void NotifyUser(string strMessage, NotifyType type)
           {
               // If called from the UI thread, then update immediately.
               // Otherwise, schedule a task on the UI thread to perform the update.
               if (Dispatcher.HasThreadAccess)
               {
                   UpdateStatus(strMessage, type);
               }
               else
               {
                   var task = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => UpdateStatus(strMessage, type));
               }
           }
   
           private void UpdateStatus(string strMessage, NotifyType type)
           {
               switch (type)
               {
                   case NotifyType.StatusMessage:
                       StatusBorder.Background = new SolidColorBrush(Windows.UI.Colors.Green);
                       break;
                   case NotifyType.ErrorMessage:
                       StatusBorder.Background = new SolidColorBrush(Windows.UI.Colors.Red);
                       break;
               }
               StatusBlock.Text += string.IsNullOrEmpty(StatusBlock.Text) ? strMessage : "\n" + strMessage;
   
               // Collapse the StatusBlock if it has no text to conserve real estate.
               StatusBorder.Visibility = !string.IsNullOrEmpty(StatusBlock.Text) ? Visibility.Visible : Visibility.Collapsed;
               if (!string.IsNullOrEmpty(StatusBlock.Text))
               {
                   StatusBorder.Visibility = Visibility.Visible;
                   StatusPanel.Visibility = Visibility.Visible;
               }
               else
               {
                   StatusBorder.Visibility = Visibility.Collapsed;
                   StatusPanel.Visibility = Visibility.Collapsed;
               }
               // Raise an event if necessary to enable a screen reader to announce the status update.
               var peer = Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer.FromElement(StatusBlock);
               if (peer != null)
               {
                   peer.RaiseAutomationEvent(Windows.UI.Xaml.Automation.Peers.AutomationEvents.LiveRegionChanged);
               }
           }
       }
   }
   

Create a Speech configuration

Before you can initialize a SpeechRecognizer object, you need to create a configuration that uses your subscription key and subscription region. Insert this code in the RecognizeSpeechAsync() method.

// Creates an instance of a speech config with specified subscription key and service region.
// Replace with your own subscription key and service region (e.g., "westus").
var config = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");

Initialize a SpeechRecognizer

Now, let's create a SpeechRecognizer. This object is created inside of a using statement to ensure the proper release of unmanaged resources. Insert this code in the RecognizeSpeechAsync() method, right below your Speech configuration.

using (var recognizer = new SpeechRecognizer(config))
{
}

Recognize a phrase

From the SpeechRecognizer object, you're going to call the RecognizeOnceAsync() method. This method lets the Speech service know that you're sending a single phrase for recognition, and that once the phrase is identified to stop recognizing speech.

Inside the using statement, add this code.

var result = await recognizer.RecognizeOnceAsync().ConfigureAwait(false);

Display the recognition results (or errors)

When the recognition result is returned by the Speech service, you'll want to do something with it. We're going to keep it simple and print the result to the status panel.

    // Checks result.
    StringBuilder sb = new StringBuilder();
    if (result.Reason == ResultReason.RecognizedSpeech)
    {
        sb.AppendLine($"RECOGNIZED: Text={result.Text}");
    }
    else if (result.Reason == ResultReason.NoMatch)
    {
        sb.AppendLine($"NOMATCH: Speech could not be recognized.");
    }
    else if (result.Reason == ResultReason.Canceled)
    {
        var cancellation = CancellationDetails.FromResult(result);
        sb.AppendLine($"CANCELED: Reason={cancellation.Reason}");

        if (cancellation.Reason == CancellationReason.Error)
        {
            sb.AppendLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
            sb.AppendLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
            sb.AppendLine($"CANCELED: Did you update the subscription info?");
        }
    }

    // Update the UI
    NotifyUser(sb.ToString(), NotifyType.StatusMessage);
}

Build and run the application

Now you are ready to build and test your application.

1. From the menu bar, choose Build > Build Solution to build the application. The code should compile without errors now.

2. Choose Debug > Start Debugging (or press F5) to start the application. The helloworld window appears.

   

3. Select Enable Microphone, and when the access permission request pops up, select Yes.

   

4. Select Speech recognition with microphone input, and speak an English phrase or sentence into your device's microphone. Your speech is transmitted to the Speech service and transcribed to text, which appears in the window.

   

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

If you've already done this, great. Let's keep going.

Add sample code for the common helloworld project

The common helloworld project contains platform-independent implementations for your cross-platform application. Now add the XAML code that defines the user interface of the application, and add the C# code behind the implementation.

1. In Solution Explorer, under the common helloworld project, open MainPage.xaml.

2. In the designer's XAML view, insert the following XAML snippet into the Grid tag between <StackLayout> and </StackLayout>:

   <?xml version="1.0" encoding="utf-8" ?>
   <ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
                xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                xmlns:local="clr-namespace:helloworld"
                x:Class="helloworld.MainPage">
   
       <StackLayout Spacing="10" x:Name="layout" Padding="0,40,0,0">
           <Label x:Name="RecognitionText"               
                  FontSize="Small"
                  HeightRequest="100"
                  HorizontalOptions="FillAndExpand" />
   
           <Button x:Name="EnableMicrophoneButton"
                   Text="Enable microphone"
                   HorizontalOptions="FillAndExpand"
                   Clicked="OnEnableMicrophoneButtonClicked" />
   
           <Button x:Name="RecognitionButton"
                   Text="Start speech recognition"
                   HorizontalOptions="FillAndExpand"
                   Clicked="OnRecognitionButtonClicked" />
       </StackLayout>
   
   </ContentPage>
   

3. In Solution Explorer, open the code-behind source file MainPage.xaml.cs. It's grouped under MainPage.xaml.

4. Replace all the code in it with the following snippet:

   //
   // Copyright (c) Microsoft. All rights reserved.
   // Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
   //
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   using Xamarin.Forms;
   using Microsoft.CognitiveServices.Speech;
   
   namespace helloworld
   {
       public partial class MainPage : ContentPage
       {
           public MainPage()
           {
               InitializeComponent();
           }
   
           private async void OnRecognitionButtonClicked(object sender, EventArgs e)
           {
               try
               {
                   // Creates an instance of a speech config with specified subscription key and service region.
                   // Replace with your own subscription key and service region (e.g., "westus").
                   var config = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourRegion");
   
                   // Creates a speech recognizer using microphone as audio input.
                   using (var recognizer = new SpeechRecognizer(config))
                   {
                       // Starts speech recognition, and returns after a single utterance is recognized. The end of a
                       // single utterance is determined by listening for silence at the end or until a maximum of 15
                       // seconds of audio is processed.  The task returns the recognition text as result.
                       // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
                       // shot recognition like command or query.
                       // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
                       var result = await recognizer.RecognizeOnceAsync().ConfigureAwait(false);
   
                       // Checks result.
                       StringBuilder sb = new StringBuilder();
                       if (result.Reason == ResultReason.RecognizedSpeech)
                       {
                           sb.AppendLine($"RECOGNIZED: Text={result.Text}");
                       }
                       else if (result.Reason == ResultReason.NoMatch)
                       {
                           sb.AppendLine($"NOMATCH: Speech could not be recognized.");
                       }
                       else if (result.Reason == ResultReason.Canceled)
                       {
                           var cancellation = CancellationDetails.FromResult(result);
                           sb.AppendLine($"CANCELED: Reason={cancellation.Reason}");
   
                           if (cancellation.Reason == CancellationReason.Error)
                           {
                               sb.AppendLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
                               sb.AppendLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
                               sb.AppendLine($"CANCELED: Did you update the subscription info?");
                           }
                       }
   
                       UpdateUI(sb.ToString());
                   }
               }
               catch (Exception ex)
               {
                   UpdateUI("Exception: " + ex.ToString());
               }
           }
   
           private async void OnEnableMicrophoneButtonClicked(object sender, EventArgs e)
           {
               bool micAccessGranted = await DependencyService.Get<IMicrophoneService>().GetPermissionsAsync();
               if (!micAccessGranted)
               {
                   UpdateUI("Please give access to microphone");
               }
           }
   
           private void UpdateUI(String message)
           {
               Device.BeginInvokeOnMainThread(() =>
               {
                   RecognitionText.Text = message;
               });
           }
       }
   }
   

5. In the source file's OnRecognitionButtonClicked handler, find the string YourSubscriptionKey, and replace it with your subscription key.

6. In the OnRecognitionButtonClicked handler, find the string YourServiceregion, and replace it with the Region identifier from region associated with your subscription. (For example, use westus for the free trial subscription.)

7. Next, you need to create a Xamarin Service, which is used to query microphone permissions from different platform projects, such as UWP, Android, and iOS. To do that, add a new folder named Services under the helloworld project, and create a new C# source file under it. You can right-click the Services folder, and select Add > New Item > Code File. Rename the file IMicrophoneService.cs, and place all code from the following snippet in that file:

   //
   // Copyright (c) Microsoft. All rights reserved.
   // Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
   //
   using System.Threading.Tasks;
   
   namespace helloworld
   {
       public interface IMicrophoneService
       {
           Task<bool> GetPermissionsAsync();
           void OnRequestPermissionsResult(bool isGranted);
       }
   }
   

Build and run the Android and iOS applications

Building and running Android and iOS applications in the device or simulator happen in a similar way to the UWP. Make sure all SDKs are installed correctly as required in the "Prerequisites" section of this article.

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

Source code

Create a C++ source file named helloworld.cpp, and paste the following code into it.

#include <iostream> // cin, cout
#include <speechapi_cxx.h>

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

void recognizeSpeech() {
    // Creates an instance of a speech config with specified subscription key and service region.
    // Replace with your own subscription key and service region (e.g., "westus").
    auto config = SpeechConfig::FromSubscription("YourSubscriptionKey", "YourServiceRegion");

    // Creates a speech recognizer
    auto recognizer = SpeechRecognizer::FromConfig(config);
    cout << "Say something...\n";

    // Starts speech recognition, and returns after a single utterance is recognized. The end of a
    // single utterance is determined by listening for silence at the end or until a maximum of 15
    // seconds of audio is processed.  The task returns the recognition text as result. 
    // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
    // shot recognition like command or query. 
    // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
    auto result = recognizer->RecognizeOnceAsync().get();

    // Checks result.
    if (result->Reason == ResultReason::RecognizedSpeech) {
        cout << "We recognized: " << result->Text << std::endl;
    }
    else if (result->Reason == ResultReason::NoMatch) {
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
    }
    else if (result->Reason == ResultReason::Canceled) {
        auto cancellation = CancellationDetails::FromResult(result);
        cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;

        if (cancellation->Reason == CancellationReason::Error) {
            cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
            cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
            cout << "CANCELED: Did you update the subscription info?" << std::endl;
        }
    }
}

int main(int argc, char **argv) {
    setlocale(LC_ALL, "");
    recognizeSpeech();
    return 0;
}

Replace the YourSubscriptionKey and YourServiceRegion values with actual values from the Speech resource.

• Navigate to the Azure portal , and open the Speech resource
• Under the Keys on the left, there are two available subscription keys
  • Use either one as the YourSubscriptionKey value replacement
• Under the Overview on the left, note the region and map it to the region identifier
  • Use the Region identifier as the YourServiceRegion value replacement, for example: "westus" for West US

Code explanation

The Speech resource subscription key and region are required to create a speech configuration object. The configuration object is needed to instantiate a speech recognizer object.

The recognizer instance exposes multiple ways to recognize speech. In this example, speech is recognized once. This functionality lets the Speech service know that you're sending a single phrase for recognition, and that once the phrase is identified to stop recognizing speech. Once the result is yielded, the code will write the recognition reason to the console.

Build the app

• On an x64 (64-bit) system, run the following command to build the application.

  g++ helloworld.cpp -o helloworld -I "$SPEECHSDK_ROOT/include/cxx_api" -I "$SPEECHSDK_ROOT/include/c_api" --std=c++14 -lpthread -lMicrosoft.CognitiveServices.Speech.core -L "$SPEECHSDK_ROOT/lib/x64" -l:libasound.so.2
  

• On an x86 (32-bit) system, run the following command to build the application.

  g++ helloworld.cpp -o helloworld -I "$SPEECHSDK_ROOT/include/cxx_api" -I "$SPEECHSDK_ROOT/include/c_api" --std=c++14 -lpthread -lMicrosoft.CognitiveServices.Speech.core -L "$SPEECHSDK_ROOT/lib/x86" -l:libasound.so.2
  

• On an ARM64 (64-bit) system, run the following command to build the application.

  g++ helloworld.cpp -o helloworld -I "$SPEECHSDK_ROOT/include/cxx_api" -I "$SPEECHSDK_ROOT/include/c_api" --std=c++14 -lpthread -lMicrosoft.CognitiveServices.Speech.core -L "$SPEECHSDK_ROOT/lib/arm64" -l:libasound.so.2
  

Run the app

1. Configure the loader's library path to point to the Speech SDK library.

   • On an x64 (64-bit) system, enter the following command.

     export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SPEECHSDK_ROOT/lib/x64"
     

   • On an x86 (32-bit) system, enter this command.

     export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SPEECHSDK_ROOT/lib/x86"
     

   • On an ARM64 (64-bit) system, enter the following command.

     export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SPEECHSDK_ROOT/lib/arm64"
     

2. Run the application.

   ./helloworld
   

3. In the console window, a prompt appears, requesting that you say something. Speak an English phrase or sentence. Your speech is transmitted to the Speech service and transcribed to text, which appears in the same window.

   Say something...
   We recognized: What's the weather like?
   

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

Source code

Create a C++ source file named helloworld.cpp, and paste the following code into it.

#include <iostream> // cin, cout
#include <MicrosoftCognitiveServicesSpeech/speechapi_cxx.h>

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

void recognizeSpeech() {
    // Creates an instance of a speech config with specified subscription key and service region.
    // Replace with your own subscription key and service region (e.g., "westus").
    auto config = SpeechConfig::FromSubscription("YourSubscriptionKey", "YourServiceRegion");

    // Creates a speech recognizer
    auto recognizer = SpeechRecognizer::FromConfig(config);
    cout << "Say something...\n";

    // Performs recognition. RecognizeOnceAsync() returns when the first utterance has been recognized,
    // so it is suitable only for single shot recognition like command or query. For long-running
    // recognition, use StartContinuousRecognitionAsync() instead.
    auto result = recognizer->RecognizeOnceAsync().get();

    // Checks result.
    if (result->Reason == ResultReason::RecognizedSpeech) {
        cout << "We recognized: " << result->Text << std::endl;
    }
    else if (result->Reason == ResultReason::NoMatch) {
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
    }
    else if (result->Reason == ResultReason::Canceled) {
        auto cancellation = CancellationDetails::FromResult(result);
        cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;

        if (cancellation->Reason == CancellationReason::Error) {
            cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
            cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
            cout << "CANCELED: Did you update the subscription info?" << std::endl;
        }
    }
}

int main(int argc, char **argv) {
    setlocale(LC_ALL, "");
    recognizeSpeech();
    return 0;
}

Replace the YourSubscriptionKey and YourServiceRegion values with actual values from the Speech resource.

• Navigate to the Azure portal , and open the Speech resource
• Under the Keys on the left, there are two available subscription keys
  • Use either one as the YourSubscriptionKey value replacement
• Under the Overview on the left, note the region and map it to the region identifier
  • Use the Region identifier as the YourServiceRegion value replacement, for example: "westus" for West US

Code explanation

The Speech resource subscription key and region are required to create a speech configuration object. The configuration object is needed to instantiate a speech recognizer object.

The recognizer instance exposes multiple ways to recognize speech. In this example, speech is recognized once. This functionality lets the Speech service know that you're sending a single phrase for recognition, and that once the phrase is identified to stop recognizing speech. Once the result is yielded, the code will write the recognition reason to the console.

Build the app

• Run the following command to build the application.

  g++ helloworld.cpp -o helloworld --std=c++14 -F${SPEECHSDK_ROOT} -framework MicrosoftCognitiveServicesSpeech
  

Run the app

1. Configure the loader's library path to point to the Speech SDK library.

   export DYLD_FRAMEWORK_PATH="$DYLD_FRAMEWORK_PATH:$SPEECHSDK_ROOT"
   

2. Run the application.

   ./helloworld
   

3. In the console window, a prompt appears, requesting that you say something. Speak an English phrase or sentence. Your speech is transmitted to the Speech service and transcribed to text, which appears in the same window.

   Say something...
   We recognized: What's the weather like?
   

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

Source code

Create a C++ source file named helloworld.cpp, and paste the following code into it.

#include <iostream>
#include <speechapi_cxx.h>

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

void recognizeSpeech()
{
    // Creates an instance of a speech config with specified subscription key and service region.
    // Replace with your own subscription key and service region (e.g., "westus").
    auto config = SpeechConfig::FromSubscription("YourSubscriptionKey", "YourServiceRegion");

    // Creates a speech recognizer.
    auto recognizer = SpeechRecognizer::FromConfig(config);
    cout << "Say something...\n";

    // Starts speech recognition, and returns after a single utterance is recognized. The end of a
    // single utterance is determined by listening for silence at the end or until a maximum of 15
    // seconds of audio is processed.  The task returns the recognition text as result. 
    // Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
    // shot recognition like command or query. 
    // For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
    auto result = recognizer->RecognizeOnceAsync().get();

    // Checks result.
    if (result->Reason == ResultReason::RecognizedSpeech)
    {
        cout << "We recognized: " << result->Text << std::endl;
    }
    else if (result->Reason == ResultReason::NoMatch)
    {
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
    }
    else if (result->Reason == ResultReason::Canceled)
    {
        auto cancellation = CancellationDetails::FromResult(result);
        cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;

        if (cancellation->Reason == CancellationReason::Error) 
        {
            cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
            cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
            cout << "CANCELED: Did you update the subscription info?" << std::endl;
        }
    }
}

int wmain()
{
    recognizeSpeech();
    cout << "Please press a key to continue.\n";
    cin.get();
    return 0;
}

Replace the YourSubscriptionKey and YourServiceRegion values with actual values from the Speech resource.

• Navigate to the Azure portal , and open the Speech resource
• Under the Keys on the left, there are two available subscription keys
  • Use either one as the YourSubscriptionKey value replacement
• Under the Overview on the left, note the region and map it to the region identifier
  • Use the Region identifier as the YourServiceRegion value replacement, for example: "westus" for West US

Code explanation

The Speech resource subscription key and region are required to create a speech configuration object. The configuration object is needed to instantiate a speech recognizer object.

The recognizer instance exposes multiple ways to recognize speech. In this example, speech is recognized once. This functionality lets the Speech service know that you're sending a single phrase for recognition, and that once the phrase is identified to stop recognizing speech. Once the result is yielded, the code will write the recognition reason to the console.

Build and run app

1. From the menu bar, select Build > Build Solution to build the application. The code should compile without errors now.

2. Choose Debug > Start Debugging (or press F5) to start the helloworld application.

3. Speak an English phrase or sentence. The application transmits your speech to the Speech service, which transcribes to text and sends it back to the application for display.

   

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

Source code

To add a new empty class to your Java project, select File > New > Class. In the New Java Class window, enter speechsdk.quickstart into the Package field, and Main into the Name field.

Replace the contents of the Main.java file with the following snippet:

package speechsdk.quickstart;

import java.util.concurrent.Future;
import com.microsoft.cognitiveservices.speech.*;

/**
 * Quickstart: recognize speech using the Speech SDK for Java.
 */
public class Main {

    /**
     * @param args Arguments are ignored in this sample.
     */
    public static void main(String[] args) {
        try {
            // Replace below with your own subscription key
            String speechSubscriptionKey = "YourSubscriptionKey";
            // Replace below with your own service region (e.g., "westus").
            String serviceRegion = "YourServiceRegion";

            int exitCode = 1;
            SpeechConfig config = SpeechConfig.fromSubscription(speechSubscriptionKey, serviceRegion);
            assert(config != null);

            SpeechRecognizer reco = new SpeechRecognizer(config);
            assert(reco != null);

            System.out.println("Say something...");

            Future<SpeechRecognitionResult> task = reco.recognizeOnceAsync();
            assert(task != null);

            SpeechRecognitionResult result = task.get();
            assert(result != null);

            if (result.getReason() == ResultReason.RecognizedSpeech) {
                System.out.println("We recognized: " + result.getText());
                exitCode = 0;
            }
            else if (result.getReason() == ResultReason.NoMatch) {
                System.out.println("NOMATCH: Speech could not be recognized.");
            }
            else if (result.getReason() == ResultReason.Canceled) {
                CancellationDetails cancellation = CancellationDetails.fromResult(result);
                System.out.println("CANCELED: Reason=" + cancellation.getReason());

                if (cancellation.getReason() == CancellationReason.Error) {
                    System.out.println("CANCELED: ErrorCode=" + cancellation.getErrorCode());
                    System.out.println("CANCELED: ErrorDetails=" + cancellation.getErrorDetails());
                    System.out.println("CANCELED: Did you update the subscription info?");
                }
            }

            reco.close();

            System.exit(exitCode);
        } catch (Exception ex) {
            System.out.println("Unexpected exception: " + ex.getMessage());

            assert(false);
            System.exit(1);
        }
    }
}

Replace the YourSubscriptionKey and YourServiceRegion values with actual values from the Speech resource.

• Navigate to the Azure portal , and open the Speech resource
• Under the Keys on the left, there are two available subscription keys
  • Use either one as the YourSubscriptionKey value replacement
• Under the Overview on the left, note the region and map it to the region identifier
  • Use the Region identifier as the YourServiceRegion value replacement, for example: "westus" for West US

Code explanation

The Speech resource subscription key and region are required to create a speech configuration object. The configuration object is needed to instantiate a speech recognizer object.

The recognizer instance exposes multiple ways to recognize speech. In this example, speech is recognized once. This functionality lets the Speech service know that you're sending a single phrase for recognition, and that once the phrase is identified to stop recognizing speech. Once the result is yielded, the code will write the recognition reason to the console.

Build and run app

Press F11, or select Run > Debug. The next 15 seconds of speech input from your microphone will be recognized and logged in the console window.

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Prerequisites

Before you get started:

Create a user interface

Now we'll create a basic user interface for the application. Edit the layout for your main activity, activity_main.xml. Initially, the layout includes a title bar with your application's name, and a TextView that contains the text "Hello World!".

• Select the TextView element. Change its ID attribute in the upper-right corner to hello.

• From the palette in the upper left of the activity_main.xml window, drag a button into the empty space above the text.

• In the button's attributes on the right, in the value for the onClick attribute, enter onSpeechButtonClicked. We'll write a method with this name to handle the button event. Change its ID attribute in the upper-right corner to button.

• Use the magic wand icon at the top of the designer to infer layout constraints.

  

The text and graphical representation of your UI should now look like this:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/hello"
        android:layout_width="366dp"
        android:layout_height="295dp"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.925" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="16dp"
        android:onClick="onSpeechButtonClicked"
        android:text="Button"
        app:layout_constraintBottom_toTopOf="@+id/hello"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.072" />

</android.support.constraint.ConstraintLayout>

Add sample code

1. Open the source file MainActivity.java. Replace all the code in this file with the following:

   package com.microsoft.cognitiveservices.speech.samples.quickstart;
   
   import android.support.v4.app.ActivityCompat;
   import android.support.v7.app.AppCompatActivity;
   import android.os.Bundle;
   import android.util.Log;
   import android.view.View;
   import android.widget.TextView;
   
   import com.microsoft.cognitiveservices.speech.ResultReason;
   import com.microsoft.cognitiveservices.speech.SpeechConfig;
   import com.microsoft.cognitiveservices.speech.SpeechRecognitionResult;
   import com.microsoft.cognitiveservices.speech.SpeechRecognizer;
   
   import java.util.concurrent.Future;
   
   import static android.Manifest.permission.*;
   
   public class MainActivity extends AppCompatActivity {
   
       // Replace below with your own subscription key
       private static String speechSubscriptionKey = "YourSubscriptionKey";
       // Replace below with your own service region (e.g., "westus").
       private static String serviceRegion = "YourServiceRegion";
   
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);
   
           // Note: we need to request the permissions
           int requestCode = 5; // unique code for the permission request
           ActivityCompat.requestPermissions(MainActivity.this, new String[]{RECORD_AUDIO, INTERNET}, requestCode);
       }
   
       public void onSpeechButtonClicked(View v) {
           TextView txt = (TextView) this.findViewById(R.id.hello); // 'hello' is the ID of your text view
   
           try {
               SpeechConfig config = SpeechConfig.fromSubscription(speechSubscriptionKey, serviceRegion);
               assert(config != null);
   
               SpeechRecognizer reco = new SpeechRecognizer(config);
               assert(reco != null);
   
               Future<SpeechRecognitionResult> task = reco.recognizeOnceAsync();
               assert(task != null);
   
               // Note: this will block the UI thread, so eventually, you want to
               //        register for the event (see full samples)
               SpeechRecognitionResult result = task.get();
               assert(result != null);
   
               if (result.getReason() == ResultReason.RecognizedSpeech) {
                   txt.setText(result.toString());
               }
               else {
                   txt.setText("Error recognizing. Did you update the subscription info?" + System.lineSeparator() + result.toString());
               }
   
               reco.close();
           } catch (Exception ex) {
               Log.e("SpeechSDKDemo", "unexpected " + ex.getMessage());
               assert(false);
           }
       }
   }
   

   • The onCreate method includes code that requests microphone and internet permissions, and initializes the native platform binding. Configuring the native platform bindings is only required once. It should be done early during application initialization.

   • The method onSpeechButtonClicked is, as noted earlier, the button click handler. A button press triggers speech-to-text transcription.

2. In the same file, replace the string YourSubscriptionKey with your subscription key.

3. Also replace the string YourServiceRegion with the Region identifier from region associated with your subscription. For example, use westus for the free trial subscription.

Build and run the app

1. Connect your Android device to your development PC. Make sure that you enabled development mode and USB debugging on the device.

2. To build the application, select Ctrl+F9, or select Build > Make Project from the menu bar.

3. To launch the application, select Shift+F10, or select Run > Run 'app'.

4. In the deployment target window that appears, select your Android device.

   

Select the button in the application to begin a speech recognition section. The next 15 seconds of English speech will be sent to the Speech service and transcribed. The result appears in the Android application, and in the logcat window in Android Studio.

Next steps

With this base knowledge of speech recognition, continue exploring the basics to learn about common functionality and tasks within the Speech SDK.

Follow these steps to install the Speech CLI on Windows:

1. Install either .NET Framework 4.7 or .NET Core 3.0
2. Download the Speech CLI zip archive, then extract it.
3. Go to the root directory spx-zips that you extracted from the download, and extract the subdirectory that you need (spx-net471 for .NET Framework 4.7, or spx-netcore-win-x64 for .NET Core 3.0 on an x64 CPU).

In the command prompt, change directory to this location, and then type spx to see help for the Speech CLI.

Follow these steps to install the Speech CLI on Linux on an x64 CPU:

1. Install .NET Core 3.0.
2. Download the Speech CLI zip archive, then extract it.
3. Go to the root directory spx-zips that you extracted from the download, and extract spx-netcore-30-linux-x64 to a new ~/spx directory.
4. In a terminal, type these commands:
   1. cd ~/spx
   2. sudo chmod +r+x spx
   3. PATH=~/spx:$PATH

Type spx to see help for the Speech CLI.