Quickstart: Een Custom Voice-assistent maken

In deze quickstart gebruikt u de Speech SDK om een aangepaste toepassing voor de spraakassistenten te maken die verbinding maakt met een bot die u al hebt gemaakt en geconfigureerd. Als u een bot wilt maken, raadpleegt u de bijbehorende zelfstudie voor een uitgebreidere handleiding.

Als u aan de vereisten hebt voldaan, kunt u de aangepaste spraakassistent in een paar stappen koppelen:

• Maak een BotFrameworkConfig-object op basis van uw abonnementssleutel en -regio.
• Maak een DialogServiceConnector-object met bovenstaande BotFrameworkConfig-object.
• Gebruik het DialogServiceConnector-object om het luisterproces voor één uiting te starten.
• Inspecteer de geretourneerde ActivityReceivedEventArgs.

Notitie

De Speech SDK voor C++, JavaScript, Objective-C, Python en Swift ondersteunen aangepaste spraakassistenten, maar we hebben hier nog geen handleiding toegevoegd.

U kunt alle C#-voorbeelden van de Speech SDK op GitHub bekijken of downloaden.

Vereisten

Voordat u aan de slag gaat, moet u het volgende doen:

• Een spraakresource maken
• Uw ontwikkelomgeving instellen en een leeg project maken
• Een bot maken die verbonden is met het Direct Line Speech-kanaal
• Ervoor zorgen dat u toegang tot een microfoon hebt voor het vastleggen van audio

Notitie

Raadpleeg de lijst met ondersteunde regio's voor spraakassistenten en zorg ervoor dat uw resources in een van deze regio's worden geïmplementeerd.

Open uw project in Visual Studio

De eerste stap is het openen van uw project in Visual Studio.

Beginnen met standaardcode

We gaan wat code toevoegen die als basis voor het project gaat dienen.

1. In Solution Explorer opent u MainPage.xaml.

2. Vervang in de XAML-ontwerpweergave de volledige inhoud door het volgende codefragment dat een elementaire gebruikersinterface definieert:

   <Page
       x:Class="helloworld.MainPage"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       xmlns:local="using:helloworld"
       xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
       xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
       mc:Ignorable="d"
       Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
   
       <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="ListenButton" Content="Talk to your bot" 
                       Margin="0,10,10,0" Click="ListenButton_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>
           <MediaElement x:Name="mediaElement"/>
       </Grid>
   </Page>
   

De Ontwerpweergave is bijgewerkt om de gebruikersinterface van de toepassing weer te geven.

1. Open in Solution Explorer het code-behind-bronbestand MainPage.xaml.cs. (Het is gegroepeerd onder MainPage.xaml.) Vervang de inhoud van dit bestand door het onderstaande, inclusief:

• using instructies voor de Speech- en Speech.Dialog-naamruimten

• Een eenvoudige implementatie om toegang tot de microfoon te garanderen, aangesloten op een knop-handler

• Basic UI-helpers om berichten en fouten in de toepassing weer te geven

• Een landingspunt voor het pad van de initialisatiecode dat later wordt ingevuld

• Een helper voor het afspelen van tekst naar spraak (zonder ondersteuning voor streaming)

• Een lege knop-handler om te luisteren die later wordt ingevuld

  using Microsoft.CognitiveServices.Speech;
  using Microsoft.CognitiveServices.Speech.Audio;
  using Microsoft.CognitiveServices.Speech.Dialog;
  using System;
  using System.Diagnostics;
  using System.IO;
  using System.Text;
  using Windows.Foundation;
  using Windows.Storage.Streams;
  using Windows.UI.Xaml;
  using Windows.UI.Xaml.Controls;
  using Windows.UI.Xaml.Media;
  
  namespace helloworld
  {
      public sealed partial class MainPage : Page
      {
          private DialogServiceConnector connector;
  
          private enum NotifyType
          {
              StatusMessage,
              ErrorMessage
          };
  
          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 void NotifyUser(
              string strMessage, NotifyType type = NotifyType.StatusMessage)
          {
              // 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;
  
              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);
              }
          }
  
          // Waits for and accumulates all audio associated with a given 
          // PullAudioOutputStream and then plays it to the MediaElement. Long spoken 
          // audio will create extra latency and a streaming playback solution 
          // (that plays audio while it continues to be received) should be used -- 
          // see the samples for examples of this.
          private void SynchronouslyPlayActivityAudio(
              PullAudioOutputStream activityAudio)
          {
              var playbackStreamWithHeader = new MemoryStream();
              playbackStreamWithHeader.Write(Encoding.ASCII.GetBytes("RIFF"), 0, 4); // ChunkID
              playbackStreamWithHeader.Write(BitConverter.GetBytes(UInt32.MaxValue), 0, 4); // ChunkSize: max
              playbackStreamWithHeader.Write(Encoding.ASCII.GetBytes("WAVE"), 0, 4); // Format
              playbackStreamWithHeader.Write(Encoding.ASCII.GetBytes("fmt "), 0, 4); // Subchunk1ID
              playbackStreamWithHeader.Write(BitConverter.GetBytes(16), 0, 4); // Subchunk1Size: PCM
              playbackStreamWithHeader.Write(BitConverter.GetBytes(1), 0, 2); // AudioFormat: PCM
              playbackStreamWithHeader.Write(BitConverter.GetBytes(1), 0, 2); // NumChannels: mono
              playbackStreamWithHeader.Write(BitConverter.GetBytes(16000), 0, 4); // SampleRate: 16kHz
              playbackStreamWithHeader.Write(BitConverter.GetBytes(32000), 0, 4); // ByteRate
              playbackStreamWithHeader.Write(BitConverter.GetBytes(2), 0, 2); // BlockAlign
              playbackStreamWithHeader.Write(BitConverter.GetBytes(16), 0, 2); // BitsPerSample: 16-bit
              playbackStreamWithHeader.Write(Encoding.ASCII.GetBytes("data"), 0, 4); // Subchunk2ID
              playbackStreamWithHeader.Write(BitConverter.GetBytes(UInt32.MaxValue), 0, 4); // Subchunk2Size
  
              byte[] pullBuffer = new byte[2056];
  
              uint lastRead = 0;
              do
              {
                  lastRead = activityAudio.Read(pullBuffer);
                  playbackStreamWithHeader.Write(pullBuffer, 0, (int)lastRead);
              }
              while (lastRead == pullBuffer.Length);
  
              var task = Dispatcher.RunAsync(
                  Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
              {
                  mediaElement.SetSource(
                      playbackStreamWithHeader.AsRandomAccessStream(), "audio/wav");
                  mediaElement.Play();
              });
          }
  
          private void InitializeDialogServiceConnector()
          {
              // New code will go here
          }
  
          private async void ListenButton_ButtonClicked(
              object sender, RoutedEventArgs e)
          {
              // New code will go here
          }
      }
  }
  

1. Voeg het volgende codefragment toe aan de hoofdtekst van de methode InitializeDialogServiceConnector. Met deze code maakt u de DialogServiceConnector met uw abonnementsgegevens.

   // Create a BotFrameworkConfig by providing a Speech service subscription key
   // the botConfig.Language property is optional (default en-US)
   const string speechSubscriptionKey = "YourSpeechSubscriptionKey"; // Your subscription key
   const string region = "YourServiceRegion"; // Your subscription service region.
   
   var botConfig = BotFrameworkConfig.FromSubscription(speechSubscriptionKey, region);
   botConfig.Language = "en-US";
   connector = new DialogServiceConnector(botConfig);
   

   Notitie

   Raadpleeg de lijst met ondersteunde regio's voor spraakassistenten en zorg ervoor dat uw resources in een van deze regio's worden geïmplementeerd.

   Notitie

   Zie de Bot Framework-documentatie voor het Direct Line Speech-kanaal voor meer informatie over het configureren van uw bot.

2. Vervang de tekenreeksen YourSpeechSubscriptionKey en YourServiceRegion door uw eigen waarden voor uw spraakabonnement en regio.

3. Voeg het volgende codefragment toe aan het einde van de hoofdtekst van de methode InitializeDialogServiceConnector. Met deze code worden gebeurtenis-handlers ingesteld die worden gebruikt door DialogServiceConnector om de bot-activiteiten, de resultaten van spraakherkenning en andere informatie te communiceren.

   // ActivityReceived is the main way your bot will communicate with the client 
   // and uses bot framework activities
   connector.ActivityReceived += (sender, activityReceivedEventArgs) =>
   {
       NotifyUser(
           $"Activity received, hasAudio={activityReceivedEventArgs.HasAudio} activity={activityReceivedEventArgs.Activity}");
   
       if (activityReceivedEventArgs.HasAudio)
       {
           SynchronouslyPlayActivityAudio(activityReceivedEventArgs.Audio);
       }
   };
   
   // Canceled will be signaled when a turn is aborted or experiences an error condition
   connector.Canceled += (sender, canceledEventArgs) =>
   {
       NotifyUser($"Canceled, reason={canceledEventArgs.Reason}");
       if (canceledEventArgs.Reason == CancellationReason.Error)
       {
           NotifyUser(
               $"Error: code={canceledEventArgs.ErrorCode}, details={canceledEventArgs.ErrorDetails}");
       }
   };
   
   // Recognizing (not 'Recognized') will provide the intermediate recognized text 
   // while an audio stream is being processed
   connector.Recognizing += (sender, recognitionEventArgs) =>
   {
       NotifyUser($"Recognizing! in-progress text={recognitionEventArgs.Result.Text}");
   };
   
   // Recognized (not 'Recognizing') will provide the final recognized text 
   // once audio capture is completed
   connector.Recognized += (sender, recognitionEventArgs) =>
   {
       NotifyUser($"Final speech to text result: '{recognitionEventArgs.Result.Text}'");
   };
   
   // SessionStarted will notify when audio begins flowing to the service for a turn
   connector.SessionStarted += (sender, sessionEventArgs) =>
   {
       NotifyUser($"Now Listening! Session started, id={sessionEventArgs.SessionId}");
   };
   
   // SessionStopped will notify when a turn is complete and 
   // it's safe to begin listening again
   connector.SessionStopped += (sender, sessionEventArgs) =>
   {
       NotifyUser($"Listening complete. Session ended, id={sessionEventArgs.SessionId}");
   };
   

4. Voeg het volgende codefragment toe aan de hoofdtekst van de methode ListenButton_ButtonClicked in de klasse MainPage. Met deze code wordt DialogServiceConnector ingesteld om te luisteren, aangezien u de configuratie al hebt ingesteld en de gebeurtenis-handlers hebt geregistreerd.

   if (connector == null)
   {
       InitializeDialogServiceConnector();
       // Optional step to speed up first interaction: if not called, 
       // connection happens automatically on first use
       var connectTask = connector.ConnectAsync();
   }
   
   try
   {
       // Start sending audio to your speech-enabled bot
       var listenTask = connector.ListenOnceAsync();
   
       // You can also send activities to your bot as JSON strings -- 
       // Microsoft.Bot.Schema can simplify this
       string speakActivity = 
           @"{""type"":""message"",""text"":""Greeting Message"", ""speak"":""Hello there!""}";
       await connector.SendActivityAsync(speakActivity);
   
   }
   catch (Exception ex)
   {
       NotifyUser($"Exception: {ex.ToString()}", NotifyType.ErrorMessage);
   }
   

De app bouwen en uitvoeren

U bent nu klaar om uw app te bouwen en uw aangepaste spraakassistent met behulp van de Spraakservice te testen.

1. Kies in de menubalk Build>Build Solution om de toepassing te bouwen. De code moet nu zonder fouten worden gecompileerd.

2. Kies Debug>Start Debugging (of druk op F5) om de toepassing te starten. Het venster helloworld wordt weergegeven.

   

3. Selecteer Enable Microphone, en selecteer Yes wanneer het toegangsverzoek verschijnt.

   

4. Selecteer Praten tegen bot en zeg in het Engels een woordgroep of zin in de microfoon van uw apparaat. De gesproken tekst wordt verzonden naar de Direct Line Speech-service en getranscribeerd naar tekst, die in het venster wordt weergegeven.

Volgende stappen

C#-voorbeelden op GitHub bekijken

---

U kunt alle Java-voorbeelden van de Speech SDK op GitHub bekijken of downloaden.

Uw doelomgeving kiezen

Java Runtime

Vereisten

Voordat u aan de slag gaat, moet u het volgende doen:

• Een spraakresource maken
• Uw ontwikkelomgeving instellen en een leeg project maken
• Een bot maken die verbonden is met het Direct Line Speech-kanaal
• Ervoor zorgen dat u toegang tot een microfoon hebt voor het vastleggen van audio

Notitie

Raadpleeg de lijst met ondersteunde regio's voor spraakassistenten en zorg ervoor dat uw resources in een van deze regio's worden geïmplementeerd.

Project maken en configureren

Maak een Eclipse-project en installeer de Speech SDK.

Als u logboekregistratie wilt inschakelen, moet u ook het bestand pom.xml bijwerken met de volgende afhankelijkheid:

 <dependency>
     <groupId>org.slf4j</groupId>
     <artifactId>slf4j-simple</artifactId>
     <version>1.7.5</version>
 </dependency>

Voorbeeldcode toevoegen

1. Om een nieuwe lege klasse aan uw Java-project toe te voegen, selecteert u Bestand>Nieuw>Klasse.

2. Voer in het venster Nieuwe Java-klasse, in het veld Pakket, speechsdk.quickstart in en voer in het veld NaamMain in.

   

3. Open de zojuist gemaakte klasse Main, en vervang de inhoud van het bestand Main.java door de volgende begincode:

   package speechsdk.quickstart;
   
   import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
   import com.microsoft.cognitiveservices.speech.audio.PullAudioOutputStream;
   import com.microsoft.cognitiveservices.speech.dialog.BotFrameworkConfig;
   import com.microsoft.cognitiveservices.speech.dialog.DialogServiceConnector;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import javax.sound.sampled.AudioFormat;
   import javax.sound.sampled.AudioSystem;
   import javax.sound.sampled.DataLine;
   import javax.sound.sampled.SourceDataLine;
   import java.io.InputStream;
   
   public class Main {
       final Logger log = LoggerFactory.getLogger(Main.class);
   
       public static void main(String[] args) {
           // New code will go here
       }
   
       private void playAudioStream(PullAudioOutputStream audio) {
           ActivityAudioStream stream = new ActivityAudioStream(audio);
           final ActivityAudioStream.ActivityAudioFormat audioFormat = stream.getActivityAudioFormat();
           final AudioFormat format = new AudioFormat(
                   AudioFormat.Encoding.PCM_SIGNED,
                   audioFormat.getSamplesPerSecond(),
                   audioFormat.getBitsPerSample(),
                   audioFormat.getChannels(),
                   audioFormat.getFrameSize(),
                   audioFormat.getSamplesPerSecond(),
                   false);
           try {
               int bufferSize = format.getFrameSize();
               final byte[] data = new byte[bufferSize];
   
               SourceDataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
               SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info);
               line.open(format);
   
               if (line != null) {
                   line.start();
                   int nBytesRead = 0;
                   while (nBytesRead != -1) {
                       nBytesRead = stream.read(data);
                       if (nBytesRead != -1) {
                           line.write(data, 0, nBytesRead);
                       }
                   }
                   line.drain();
                   line.stop();
                   line.close();
               }
               stream.close();
   
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
   }
   

4. Configureer eerst uw DialogServiceConfig in de methode main en gebruik deze voor het maken van een DialogServiceConnector-instantie. Deze instantie maakt verbinding met het Direct Line Speech-kanaal voor de interactie met uw bot. Een AudioConfig-instantie wordt ook gebruikt voor het opgeven van de bron voor audio-invoer. In dit voorbeeld wordt de standaardmicrofoon gebruikt met AudioConfig.fromDefaultMicrophoneInput().

   • Vervang de tekenreeks YourSubscriptionKey door uw spraakresourcesleutel, die u kunt ophalen uit de Azure Portal.
   • Vervang de tekenreeks YourServiceRegion door de regio die is gekoppeld aan uw Spraak-resource.

   Notitie

   Raadpleeg de lijst met ondersteunde regio's voor spraakassistenten en zorg ervoor dat uw resources in een van deze regio's worden geïmplementeerd.

   final String subscriptionKey = "YourSubscriptionKey"; // Your subscription key
   final String region = "YourServiceRegion"; // Your speech subscription service region
   final BotFrameworkConfig botConfig = BotFrameworkConfig.fromSubscription(subscriptionKey, region);
   
   // Configure audio input from a microphone.
   final AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
   
   // Create a DialogServiceConnector instance.
   final DialogServiceConnector connector = new DialogServiceConnector(botConfig, audioConfig);
   

5. De connector DialogServiceConnector is afhankelijk van verschillende gebeurtenissen om de activiteiten van bots, resultaten van spraakherkenning en andere informatie te communiceren. Voeg nu de volgende gebeurtenislisteners toe.

   // Recognizing will provide the intermediate recognized text while an audio stream is being processed.
   connector.recognizing.addEventListener((o, speechRecognitionResultEventArgs) -> {
       log.info("Recognizing speech event text: {}", speechRecognitionResultEventArgs.getResult().getText());
   });
   
   // Recognized will provide the final recognized text once audio capture is completed.
   connector.recognized.addEventListener((o, speechRecognitionResultEventArgs) -> {
       log.info("Recognized speech event reason text: {}", speechRecognitionResultEventArgs.getResult().getText());
   });
   
   // SessionStarted will notify when audio begins flowing to the service for a turn.
   connector.sessionStarted.addEventListener((o, sessionEventArgs) -> {
       log.info("Session Started event id: {} ", sessionEventArgs.getSessionId());
   });
   
   // SessionStopped will notify when a turn is complete and it's safe to begin listening again.
   connector.sessionStopped.addEventListener((o, sessionEventArgs) -> {
       log.info("Session stopped event id: {}", sessionEventArgs.getSessionId());
   });
   
   // Canceled will be signaled when a turn is aborted or experiences an error condition.
   connector.canceled.addEventListener((o, canceledEventArgs) -> {
       log.info("Canceled event details: {}", canceledEventArgs.getErrorDetails());
       connector.disconnectAsync();
   });
   
   // ActivityReceived is the main way your bot will communicate with the client and uses Bot Framework activities.
   connector.activityReceived.addEventListener((o, activityEventArgs) -> {
       final String act = activityEventArgs.getActivity().serialize();
           log.info("Received activity {} audio", activityEventArgs.hasAudio() ? "with" : "without");
           if (activityEventArgs.hasAudio()) {
               playAudioStream(activityEventArgs.getAudio());
           }
       });
   

6. Verbind DialogServiceConnector met Direct Line Speech door de methode connectAsync() aan te roepen. U kunt de bot testen door de methode listenOnceAsync voor het verzenden van audio-invoer van uw microfoon aan te roepen. U kunt ook de methode sendActivityAsync gebruiken voor het verzenden van een aangepaste activiteit als een geserialiseerde tekenreeks. Deze aangepaste activiteiten kunnen extra gegevens leveren die uw bot in het gesprek gebruikt.

   connector.connectAsync();
   // Start listening.
   System.out.println("Say something ...");
   connector.listenOnceAsync();
   
   // connector.sendActivityAsync(...)
   

7. Sla de wijzigingen in het bestand Main op.

8. Als u het afspelen van antwoorden wilt ondersteunen, voegt u een extra klasse toe die het PullAudioOutputStream-object, dat is geretourneerd door de getAudio()-API, transformeert naar een Java-InputStream voor een gemakkelijke verwerking. ActivityAudioStream is een speciale klasse die audio-respons van het Direct Line Speech-kanaal. De klasse levert accessors voor het ophalen van audio-indelingsinformatie die vereist is voor het afspelen. Selecteer hiervoor Bestand>Nieuw>Klasse.

9. Voer in het venster Nieuwe Java-klasse, in het veld Pakket, speechsdk.quickstart in en voer in het veld NaamActivityAudioStream in.

10. Open de zojuist gemaakte ActivityAudioStream-klasse en vervang de inhoud door de volgende code:

    package com.speechsdk.quickstart;
    
    import com.microsoft.cognitiveservices.speech.audio.PullAudioOutputStream;
    
    import java.io.IOException;
    import java.io.InputStream;
    
     public final class ActivityAudioStream extends InputStream {
         /**
          * The number of samples played per second (16 kHz).
          */
         public static final long SAMPLE_RATE = 16000;
         /**
          * The number of bits in each sample of a sound that has this format (16 bits).
          */
         public static final int BITS_PER_SECOND = 16;
         /**
          * The number of audio channels in this format (1 for mono).
          */
         public static final int CHANNELS = 1;
         /**
          * The number of bytes in each frame of a sound that has this format (2).
          */
         public static final int FRAME_SIZE = 2;
    
         /**
          * Reads up to a specified maximum number of bytes of data from the audio
          * stream, putting them into the given byte array.
          *
          * @param b   the buffer into which the data is read
          * @param off the offset, from the beginning of array <code>b</code>, at which
          *            the data will be written
          * @param len the maximum number of bytes to read
          * @return the total number of bytes read into the buffer, or -1 if there
          * is no more data because the end of the stream has been reached
          */
         @Override
         public int read(byte[] b, int off, int len) {
             byte[] tempBuffer = new byte[len];
             int n = (int) this.pullStreamImpl.read(tempBuffer);
             for (int i = 0; i < n; i++) {
                 if (off + i > b.length) {
                     throw new ArrayIndexOutOfBoundsException(b.length);
                 }
                 b[off + i] = tempBuffer[i];
             }
             if (n == 0) {
                 return -1;
             }
             return n;
         }
    
         /**
          * Reads the next byte of data from the activity audio stream if available.
          *
          * @return the next byte of data, or -1 if the end of the stream is reached
          * @see #read(byte[], int, int)
          * @see #read(byte[])
          * @see #available
          * <p>
          */
         @Override
         public int read() {
             byte[] data = new byte[1];
             int temp = read(data);
             if (temp <= 0) {
                 // we have a weird situation if read(byte[]) returns 0!
                 return -1;
             }
             return data[0] & 0xFF;
         }
    
         /**
          * Reads up to a specified maximum number of bytes of data from the activity audio stream,
          * putting them into the given byte array.
          *
          * @param b the buffer into which the data is read
          * @return the total number of bytes read into the buffer, or -1 if there
          * is no more data because the end of the stream has been reached
          */
         @Override
         public int read(byte[] b) {
             int n = (int) pullStreamImpl.read(b);
             if (n == 0) {
                 return -1;
             }
             return n;
         }
    
         /**
          * Skips over and discards a specified number of bytes from this
          * audio input stream.
          *
          * @param n the requested number of bytes to be skipped
          * @return the actual number of bytes skipped
          * @throws IOException if an input or output error occurs
          * @see #read
          * @see #available
          */
         @Override
         public long skip(long n) {
             if (n <= 0) {
                 return 0;
             }
             if (n <= Integer.MAX_VALUE) {
                 byte[] tempBuffer = new byte[(int) n];
                 return read(tempBuffer);
             }
             long count = 0;
             for (long i = n; i > 0; i -= Integer.MAX_VALUE) {
                 int size = (int) Math.min(Integer.MAX_VALUE, i);
                 byte[] tempBuffer = new byte[size];
                 count += read(tempBuffer);
             }
             return count;
         }
    
         /**
          * Closes this audio input stream and releases any system resources associated
          * with the stream.
          */
         @Override
         public void close() {
             this.pullStreamImpl.close();
         }
    
         /**
          * Fetch the audio format for the ActivityAudioStream. The ActivityAudioFormat defines the sample rate, bits per sample, and the # channels.
          *
          * @return instance of the ActivityAudioFormat associated with the stream
          */
         public ActivityAudioStream.ActivityAudioFormat getActivityAudioFormat() {
             return activityAudioFormat;
         }
    
         /**
          * Returns the maximum number of bytes that can be read (or skipped over) from this
          * audio input stream without blocking.
          *
          * @return the number of bytes that can be read from this audio input stream without blocking.
          * As this implementation does not buffer, this will be defaulted to 0
          */
         @Override
         public int available() {
             return 0;
         }
    
         public ActivityAudioStream(final PullAudioOutputStream stream) {
             pullStreamImpl = stream;
             this.activityAudioFormat = new ActivityAudioStream.ActivityAudioFormat(SAMPLE_RATE, BITS_PER_SECOND, CHANNELS, FRAME_SIZE, AudioEncoding.PCM_SIGNED);
         }
    
         private PullAudioOutputStream pullStreamImpl;
    
         private ActivityAudioFormat activityAudioFormat;
    
         /**
          * ActivityAudioFormat is an internal format which contains metadata regarding the type of arrangement of
          * audio bits in this activity audio stream.
          */
         static class ActivityAudioFormat {
    
             private long samplesPerSecond;
             private int bitsPerSample;
             private int channels;
             private int frameSize;
             private AudioEncoding encoding;
    
             public ActivityAudioFormat(long samplesPerSecond, int bitsPerSample, int channels, int frameSize, AudioEncoding encoding) {
                 this.samplesPerSecond = samplesPerSecond;
                 this.bitsPerSample = bitsPerSample;
                 this.channels = channels;
                 this.encoding = encoding;
                 this.frameSize = frameSize;
             }
    
             /**
              * Fetch the number of samples played per second for the associated audio stream format.
              *
              * @return the number of samples played per second
              */
             public long getSamplesPerSecond() {
                 return samplesPerSecond;
             }
    
             /**
              * Fetch the number of bits in each sample of a sound that has this audio stream format.
              *
              * @return the number of bits per sample
              */
             public int getBitsPerSample() {
                 return bitsPerSample;
             }
    
             /**
              * Fetch the number of audio channels used by this audio stream format.
              *
              * @return the number of channels
              */
             public int getChannels() {
                 return channels;
             }
    
             /**
              * Fetch the default number of bytes in a frame required by this audio stream format.
              *
              * @return the number of bytes
              */
             public int getFrameSize() {
                 return frameSize;
             }
    
             /**
              * Fetch the audio encoding type associated with this audio stream format.
              *
              * @return the encoding associated
              */
             public AudioEncoding getEncoding() {
                 return encoding;
             }
         }
    
         /**
          * Enum defining the types of audio encoding supported by this stream.
          */
         public enum AudioEncoding {
             PCM_SIGNED("PCM_SIGNED");
    
             String value;
    
             AudioEncoding(String value) {
                 this.value = value;
             }
         }
     }
    
    

11. Sla de wijzigingen in het bestand ActivityAudioStream op.

De app bouwen en uitvoeren

Druk op F11 of selecteer Uitvoeren>Fouten opsporen. In de console wordt het bericht 'Iets zeggen' weergegeven. Spreek op dit moment een Engelse zin of zin uit die uw bot kan begrijpen. Uw spraak wordt via het Direct Line Speech-kanaal naar uw bot verzonden, waar het wordt herkend en verwerkt door uw bot. Het antwoord wordt geretourneerd als een activiteit. Als uw bot spraak retourneert als antwoord, wordt de audio afgespeeld met behulp van de klasse AudioPlayer.

Volgende stappen

Bekijk Java-voorbeelden op GitHub

Android

Vereisten

Voordat u aan de slag gaat, moet u het volgende doen:

• Een spraakresource maken
• Uw ontwikkelomgeving instellen en een leeg project maken
• Een bot maken die verbonden is met het Direct Line Speech-kanaal
• Ervoor zorgen dat u toegang tot een microfoon hebt voor het vastleggen van audio

Notitie

Raadpleeg de lijst met ondersteunde regio's voor spraakassistenten en zorg ervoor dat uw resources in een van deze regio's worden geïmplementeerd.

Een project maken en configureren

Installeer de Speech SDK met behulp van Android Studio.

Gebruikersinterface maken

In deze sectie gaan we een eenvoudige gebruikersinterface (UI) maken voor de toepassing. Laten we beginnen met de hoofdactiviteit te openen: activity_main.xml. Het basissjabloon bevat een titelbalk met de naam van de toepassing en een TextView met de boodschap 'Hallo wereld!'.

Vervang daarna de inhoud van bestand activity_main.xml door de volgende code:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 xmlns:tools="http://schemas.android.com/tools"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:orientation="vertical"
 tools:context=".MainActivity">

 <Button
     android:id="@+id/button"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:layout_gravity="center"
     android:onClick="onBotButtonClicked"
     android:text="Talk to your bot" />

 <TextView
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:text="Recognition Data"
     android:textSize="18dp"
     android:textStyle="bold" />

 <TextView
     android:id="@+id/recoText"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:text="  \n(Recognition goes here)\n" />

 <TextView
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:text="Activity Data"
     android:textSize="18dp"
     android:textStyle="bold" />

 <TextView
     android:id="@+id/activityText"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:scrollbars="vertical"
     android:text="  \n(Activities go here)\n" />

</LinearLayout>

Deze XML zorgt voor een eenvoudige gebruikersinterface om te communiceren met uw bot.

• Het button-element initieert een interactie en roept de onBotButtonClicked-methode aan wanneer erop wordt geklikt.
• Het recoText element geeft de resultaten van spraak-naar-tekst weer terwijl u met uw bot praat.
• Het activityText-element geeft de JSON-nettolading voor de meest recente Bot Framework-activiteit van uw bot weer.

De tekst en de grafische weergave van uw gebruikersinterface moeten er nu ongeveer als volgt uitzien:

Voorbeeldcode toevoegen

1. Open MainActivity.java en vervang de inhoud door de volgende code:

    package samples.speech.cognitiveservices.microsoft.com;
   
    import android.media.AudioFormat;
    import android.media.AudioManager;
    import android.media.AudioTrack;
    import android.support.v4.app.ActivityCompat;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.text.method.ScrollingMovementMethod;
    import android.view.View;
    import android.widget.TextView;
   
    import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
    import com.microsoft.cognitiveservices.speech.audio.PullAudioOutputStream;
    import com.microsoft.cognitiveservices.speech.dialog.BotFrameworkConfig;
    import com.microsoft.cognitiveservices.speech.dialog.DialogServiceConnector;
   
    import org.json.JSONException;
    import org.json.JSONObject;
   
    import static android.Manifest.permission.*;
   
    public class MainActivity extends AppCompatActivity {
        // Replace below with your own speech subscription key
        private static String speechSubscriptionKey = "YourSpeechSubscriptionKey";
        // Replace below with your own speech service region
        private static String serviceRegion = "YourSpeechServiceRegion";
   
        private DialogServiceConnector connector;
   
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
   
            TextView recoText = (TextView) this.findViewById(R.id.recoText);
            TextView activityText = (TextView) this.findViewById(R.id.activityText);
            recoText.setMovementMethod(new ScrollingMovementMethod());
            activityText.setMovementMethod(new ScrollingMovementMethod());
   
            // Note: we need to request permissions for audio input and network access
            int requestCode = 5; // unique code for the permission request
            ActivityCompat.requestPermissions(MainActivity.this, new String[]{RECORD_AUDIO, INTERNET}, requestCode);
        }
   
        public void onBotButtonClicked(View v) {
            // Recreate the DialogServiceConnector on each button press, ensuring that the existing one is closed
            if (connector != null) {
                connector.close();
                connector = null;
            }
   
            // Create the DialogServiceConnector from speech subscription information
            BotFrameworkConfig config = BotFrameworkConfig.fromSubscription(speechSubscriptionKey, serviceRegion);
            connector = new DialogServiceConnector(config, AudioConfig.fromDefaultMicrophoneInput());
   
            // Optional step: preemptively connect to reduce first interaction latency
            connector.connectAsync();
   
            // Register the DialogServiceConnector's event listeners
            registerEventListeners();
   
            // Begin sending audio to your bot
            connector.listenOnceAsync();
        }
   
        private void registerEventListeners() {
            TextView recoText = (TextView) this.findViewById(R.id.recoText); // 'recoText' is the ID of your text view
            TextView activityText = (TextView) this.findViewById(R.id.activityText); // 'activityText' is the ID of your text view
   
            // Recognizing will provide the intermediate recognized text while an audio stream is being processed
            connector.recognizing.addEventListener((o, recoArgs) -> {
                recoText.setText("  Recognizing: " + recoArgs.getResult().getText());
            });
   
            // Recognized will provide the final recognized text once audio capture is completed
            connector.recognized.addEventListener((o, recoArgs) -> {
                recoText.setText("  Recognized: " + recoArgs.getResult().getText());
            });
   
            // SessionStarted will notify when audio begins flowing to the service for a turn
            connector.sessionStarted.addEventListener((o, sessionArgs) -> {
                recoText.setText("Listening...");
            });
   
            // SessionStopped will notify when a turn is complete and it's safe to begin listening again
            connector.sessionStopped.addEventListener((o, sessionArgs) -> {
            });
   
            // Canceled will be signaled when a turn is aborted or experiences an error condition
            connector.canceled.addEventListener((o, canceledArgs) -> {
                recoText.setText("Canceled (" + canceledArgs.getReason().toString() + ") error details: {}" + canceledArgs.getErrorDetails());
                connector.disconnectAsync();
            });
   
            // ActivityReceived is the main way your bot will communicate with the client and uses bot framework activities.
            connector.activityReceived.addEventListener((o, activityArgs) -> {
                try {
                    // Here we use JSONObject only to "pretty print" the condensed Activity JSON
                    String rawActivity = activityArgs.getActivity().serialize();
                    String formattedActivity = new JSONObject(rawActivity).toString(2);
                    activityText.setText(formattedActivity);
                } catch (JSONException e) {
                    activityText.setText("Couldn't format activity text: " + e.getMessage());
                }
   
                if (activityArgs.hasAudio()) {
                    // Text to speech audio associated with the activity is 16 kHz 16-bit mono PCM data
                    final int sampleRate = 16000;
                    int bufferSize = AudioTrack.getMinBufferSize(sampleRate, AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT);
   
                    AudioTrack track = new AudioTrack(
                            AudioManager.STREAM_MUSIC,
                            sampleRate,
                            AudioFormat.CHANNEL_OUT_MONO,
                            AudioFormat.ENCODING_PCM_16BIT,
                            bufferSize,
                            AudioTrack.MODE_STREAM);
   
                    track.play();
   
                    PullAudioOutputStream stream = activityArgs.getAudio();
   
                    // Audio is streamed as it becomes available. Play it as it arrives.
                    byte[] buffer = new byte[bufferSize];
                    long bytesRead = 0;
   
                    do {
                        bytesRead = stream.read(buffer);
                        track.write(buffer, 0, (int) bytesRead);
                    } while (bytesRead == bufferSize);
   
                    track.release();
                }
            });
        }
    }
   

   • De methode onCreate omvat code die toestemming vraagt voor gebruik van de microfoon en internet.

   • De methode onBotButtonClicked is, zoals eerder gezegd, de methode voor het afhandelen van het klikken op de knop. met een druk op de knop wordt een enkele interactie ('beurt') met uw bot geactiveerd.

   • De registerEventListeners-methode toont de gebeurtenissen die gebruikt worden door de DialogServiceConnector en de basisverwerking van inkomende activiteiten.

2. Vervang in hetzelfde bestand de configuratietekenreeksen zodat deze overeenkomen met uw resources:

   • Vervang YourSpeechSubscriptionKey door uw abonnementssleutel.

   • Vervang YourServiceRegion door de regio van uw abonnement. Momenteel bieden slechts enkele regio's van Speech-service ondersteuning voor Direct Line Speech. Zie regio's voor meer informatie.

De app bouwen en uitvoeren

1. Sluit uw Android-apparaat aan op de ontwikkelmachine. Zorg ervoor dat u de ontwikkelmodus en USB-foutopsporing hebt ingeschakeld op het apparaat.

2. Druk op Ctrl + F9 om de toepassing te compileren, of kies Build>Make Project in de menubalk.

3. Als u de toepassing wilt starten, drukt u op Shift + F10 of kiest u Run>Run 'app' .

4. Kies uw Android-apparaat in het venster Select Deployment Target dat wordt weergegeven.

   

Zodra de toepassing en de bijbehorende activiteiten zijn opgestart, klikt u op de knop om met uw bot te beginnen praten. Terwijl u spreekt wordt getranscribeerde tekst weergegeven. De meest recente activiteit die u van uw bot heeft ontvangen, verschijnt wanneer die beschikbaar is. Als uw bot is geconfigureerd om gesproken antwoorden te geven, wordt de spraak-naar-tekst automatisch afgespeeld.

Volgende stappen

Bekijk Java-voorbeelden op GitHub

U kunt alle Go-voorbeelden van de Speech SDK op GitHub bekijken of downloaden.

Vereisten

Voordat u aan de slag gaat:

• Een spraakresource maken
• Uw ontwikkelomgeving instellen en een leeg project maken
• Een bot maken die verbonden is met het Direct Line Speech-kanaal
• Ervoor zorgen dat u toegang tot een microfoon hebt voor het vastleggen van audio

Notitie

Raadpleeg de lijst met ondersteunde regio's voor spraakassistenten en zorg ervoor dat uw resources in een van deze regio's worden geïmplementeerd.

Uw omgeving instellen

Werk het bestand go.mod bij met de nieuwste SDK-versie door deze regel toe te voegen

require (
    github.com/Microsoft/cognitive-services-speech-sdk-go v1.15.0
)

Beginnen met standaardcode

Vervang de inhoud van het bronbestand (bijvoorbeeld quickstart.go) door de onderstaande, die het volgende bevat:

• definitie van het 'main'-pakket
• de benodigde modules importeren uit de Speech SDK
• variabelen voor het opslaan van de botgegevens die later in deze quickstart worden vervangen
• een eenvoudige implementatie waarin de microfoon wordt gebruikt voor audio-invoer
• gebeurtenis-handlers voor verschillende gebeurtenissen die plaatsvinden tijdens spraakinteractie

package main

import (
    "fmt"
    "time"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/dialog"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    subscription :=  "YOUR_SUBSCRIPTION_KEY"
    region := "YOUR_BOT_REGION"

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer audioConfig.Close()
    config, err := dialog.NewBotFrameworkConfigFromSubscription(subscription, region)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer config.Close()
    connector, err := dialog.NewDialogServiceConnectorFromConfig(config, audioConfig)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer connector.Close()
    activityReceivedHandler := func(event dialog.ActivityReceivedEventArgs) {
        defer event.Close()
        fmt.Println("Received an activity.")
    }
    connector.ActivityReceived(activityReceivedHandler)
    recognizedHandle := func(event speech.SpeechRecognitionEventArgs) {
        defer event.Close()
        fmt.Println("Recognized ", event.Result.Text)
    }
    connector.Recognized(recognizedHandle)
    recognizingHandler := func(event speech.SpeechRecognitionEventArgs) {
        defer event.Close()
        fmt.Println("Recognizing ", event.Result.Text)
    }
    connector.Recognizing(recognizingHandler)
    connector.ListenOnceAsync()
    <-time.After(10 * time.Second)
}

Vervang de waarden YOUR_SUBSCRIPTION_KEY en YOUR_BOT_REGION door de werkelijke waarden van de Spraak-resource.

• Ga naar Azure Portal en open uw Spraak-resource

• Onder Sleutels en Eindpunt aan de linkerkant bevinden zich twee beschikbare abonnementssleutels

  • Gebruik een van beide als vervanging van de waarde YOUR_SUBSCRIPTION_KEY

• Noteer de regio onder Overzicht aan de linkerkant en wijs deze toe aan de regio-id

  • Gebruik de regio-id als vervanging van de waarde YOUR_BOT_REGION, bijvoorbeeld "westus" voor US - west

  Notitie

  Raadpleeg de lijst met ondersteunde regio's voor spraakassistenten en zorg ervoor dat uw resources in een van deze regio's worden geïmplementeerd.

  Notitie

  Zie de Bot Framework-documentatie voor het Direct Line Speech-kanaal voor meer informatie over het configureren van uw bot.

Uitleg bij de code

De sleutel en de regio voor het Spraak-abonnement zijn vereist voor het maken van een spraakconfiguratieobject. Het configuratieobject is vereist voor het instantiëren van een spraakherkenningsobject.

Het Recognizer-exemplaar biedt meerdere manieren om spraak te herkennen. In dit voorbeeld wordt spraak continu herkend. Door deze functionaliteit weet de Spraak-service dat u veel frasen ter herkenning verzendt, en dat het herkennen van spraak moet stoppen wanneer het programma wordt beëindigd. Wanneer er resultaten worden verkregen, worden deze door de code naar de console geschreven.

Bouwen en uitvoeren

U bent nu klaar om uw app te bouwen en uw aangepaste spraakassistent met behulp van de Spraakservice te testen.

1. Compileer uw project, bijvoorbeeld 'go-build'
2. Voer de module uit en spreek enkele woorden of een zin in de microfoon van uw apparaat. De gesproken tekst wordt verzonden naar de Direct Line Speech-service en getranscribeerd naar tekst, die als uitvoer wordt weergegeven.

Notitie

De Speech-SDK zal standaard herkennen met en-us voor de taal. Zie Spraak herkennen voor informatie over het kiezen van de brontaal.

Volgende stappen

Go-voorbeelden op GitHub bekijken

Aanvullende taal- en platformondersteuning

Als u op dit tabblad hebt geklikt, ziet u waarschijnlijk geen quickstart in uw favoriete computertaal. Geen zorgen: er zijn extra quickstart-materialen en codevoorbeelden beschikbaar op GitHub. Gebruik de tabel om het juiste voorbeeld voor uw combinatie van programmeertaal en platform/besturingssysteem te vinden.

Taal	Codevoorbeelden
C#	.NET Framework, .NET Core, UWP, Unity, Xamarin
C++	Windows, Linux, macOS
Java	Android, JRE
Javascript	Browser, Node.js
Objective-C	iOS, macOS
Python	Windows, Linux, macOS
Swift	iOS, macOS