Schnellstart: Erstellen eines benutzerdefinierten Sprachassistenten

In dieser Schnellstartanleitung wird mithilfe des Speech SDK eine Anwendung mit benutzerdefiniertem Sprachassistent erstellt, die eine Verbindung mit einem bereits erstellten und konfigurierten Bot herstellt. Einen umfassenden Leitfaden für die Boterstellung finden Sie bei Bedarf in diesem Tutorial.

Nach Erfüllung einiger weniger Voraussetzungen können Sie in wenigen Schritten eine Verbindung für Ihren benutzerdefinierten Sprachassistenten herstellen:

• Erstellen eines Objekts vom Typ BotFrameworkConfig auf der Grundlage Ihres Abonnementschlüssels und Ihrer Region
• Erstellen eines Objekts vom Typ DialogServiceConnector unter Verwendung des obigen Objekts BotFrameworkConfig
• Starten des Lauschprozesses für eine einzelne Äußerung unter Verwendung des Objekts DialogServiceConnector
• Überprüfen des zurückgegebenen Objekts ActivityReceivedEventArgs

Hinweis

Das Speech SDK für C++, JavaScript, Objective-C, Python und Swift unterstützt benutzerdefinierte Sprach-Assistenten, wir haben hier jedoch noch keinen Leitfaden bereitgestellt.

Sie können sich alle Speech SDK-C#-Beispiele auf GitHub ansehen oder diese herunterladen.

Voraussetzungen

Führen Sie die folgenden Schritte aus, bevor Sie beginnen:

• Erstellen einer Speech-Ressource
• Einrichten Ihrer Entwicklungsumgebung und Erstellen eines leeren Projekts
• Erstellen eines Bots, der mit dem Direct Line Speech-Kanal verbunden ist
• Stellen Sie sicher, dass Sie Zugriff auf ein Mikrofon für die Audioaufnahme haben.

Hinweis

Beachten Sie die Liste mit den unterstützten Regionen für Sprach-Assistenten, und stellen Sie sicher, dass Ihre Ressourcen in einer dieser Regionen bereitgestellt werden.

Öffnen Sie Ihr Projekt in Visual Studio.

Im ersten Schritt müssen Sie sicherstellen, dass das Projekt in Visual Studio geöffnet ist.

Beginnen mit Codebausteinen

Fügen Sie Code hinzu, der als Gerüst für das Projekt fungiert.

1. Öffnen Sie MainPage.xaml im Projektmappen-Explorer.

2. Ersetzen Sie in der XAML-Ansicht des Designers den gesamten Inhalt durch den folgenden Codeausschnitt, um eine einfache Benutzeroberfläche zu definieren:

   <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>
   

Die Designansicht wird aktualisiert und zeigt dann die Benutzeroberfläche der Anwendung an.

1. Öffnen Sie im Projektmappen-Explorer die CodeBehind-Quelldatei MainPage.xaml.cs. (Sie befindet sich unter MainPage.xaml.) Ersetzen Sie den Inhalt dieser Datei durch den weiter unten angegeben Inhalt. Dieser enthält:

• using-Anweisungen für Namespaces Speech und Speech.Dialog

• Eine einfache Implementierung zur Sicherstellung des Mikrofonzugriffs über eine verkabelte Tastenbedienung

• Grundlegende UI-Hilfsprogramme zum Anzeigen von Meldungen und Fehlern in der Anwendung

• Ein Landepunkt für den Pfad des Initialisierungscodes, der später aufgefüllt wird

• Ein Hilfsprogramm für die Wiedergabe von Sprachsynthese (ohne Streamingunterstützung)

• Ein leerer Schaltflächenhandler, um mit dem Lauschen zu beginnen, der später aufgefüllt wird

  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. Fügen Sie den folgenden Codeausschnitt zum Methodentext von InitializeDialogServiceConnector hinzu. Mit diesem Code wird das DialogServiceConnector-Element mit den Informationen zu Ihrem Abonnement erstellt.

   // 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);
   

   Hinweis

   Beachten Sie die Liste mit den unterstützten Regionen für Sprach-Assistenten, und stellen Sie sicher, dass Ihre Ressourcen in einer dieser Regionen bereitgestellt werden.

   Hinweis

   Informationen zum Konfigurieren Ihres Bots finden Sie in der Bot Framework-Dokumentation zum Direct Line Speech-Kanal.

2. Ersetzen Sie die Zeichenfolgen YourSpeechSubscriptionKey und YourServiceRegion durch Ihre eigenen Werte für Speech-Abonnement und Region.

3. Fügen Sie den folgenden Codeausschnitt am Ende des Methodentexts von InitializeDialogServiceConnector an. Mit diesem Code werden Handler für Ereignisse eingerichtet, die DialogServiceConnector zum Kommunizieren von Botaktivitäten, Spracherkennungsergebnissen und anderen Informationen verwendet.

   // 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. Fügen Sie dem Text der ListenButton_ButtonClicked-Methode in der MainPage-Klasse den folgenden Codeausschnitt hinzu. Mit diesem Code wird DialogServiceConnector zum Lauschen eingerichtet, da Sie die Konfiguration bereits erstellt und die Ereignishandler registriert haben.

   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);
   }
   

Erstellen und Ausführen der App

Sie können nun Ihre App erstellen und den benutzerdefinierten Sprachassistenten mit dem Speech-Dienst testen.

1. Wählen Sie auf der Menüleiste Erstellen>Projektmappe erstellen aus, um die Anwendung zu erstellen. Der Code sollte nun ohne Fehler kompiliert werden.

2. Wählen Sie Debuggen>Debuggen starten aus (oder drücken SieF5), um die Anwendung zu starten. Das Fenster helloworld wird angezeigt.

   

3. Wählen Sie Mikrofon aktivieren und dann in der Zugriffsberechtigungsanforderung Ja aus.

   

4. Wählen Sie Mit Ihrem Bot sprechen aus, und sprechen Sie einen englischen Ausdruck oder Satz in das Mikrofon Ihres Geräts. Ihre Spracheingabe wird an den Direct Line Speech-Kanal übermittelt, in Text transkribiert und im Fenster angezeigt.

Nächste Schritte

C#-Beispiele auf GitHub

---

Sie können sich alle Speech SDK-Java-Beispiele auf GitHub ansehen oder diese herunterladen.

Auswählen Ihrer Zielumgebung

Java Runtime

Voraussetzungen

Führen Sie die folgenden Schritte aus, bevor Sie beginnen:

• Erstellen einer Speech-Ressource
• Einrichten Ihrer Entwicklungsumgebung und Erstellen eines leeren Projekts
• Erstellen eines Bots, der mit dem Direct Line Speech-Kanal verbunden ist
• Stellen Sie sicher, dass Sie Zugriff auf ein Mikrofon für die Audioaufnahme haben.

Hinweis

Beachten Sie die Liste mit den unterstützten Regionen für Sprach-Assistenten, und stellen Sie sicher, dass Ihre Ressourcen in einer dieser Regionen bereitgestellt werden.

Erstellen und Konfigurieren des Projekts

Erstellen Sie in Eclipse-Projekt, und installieren Sie das Speech SDK.

Fügen Sie außerdem der Datei pom.xml die folgende Abhängigkeit hinzu, um die Protokollierung zu aktivieren:

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

Hinzufügen von Beispielcode

1. Um Ihrem Java-Projekt eine neue leere Klasse hinzuzufügen, wählen Sie Datei>Neu>Klasse aus.

2. Geben Sie im Fenster Neue Java-Klasse die Zeichenfolge speechsdk.quickstart in das Feld Paket und die Zeichenfolge Main in das Feld Name ein.

   

3. Öffnen Sie die neu erstellte Klasse Main, und ersetzen Sie den Inhalt der Datei Main.java durch den folgenden Startcode:

   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. In der Methode main müssen Sie zunächst DialogServiceConfig konfigurieren und damit eine DialogServiceConnector-Instanz erstellen. Diese Instanz stellt eine Verbindung mit dem Direct Line Speech-Kanal für die Interaktion mit Ihrem Bot her. Außerdem wird eine AudioConfig-Instanz verwendet, um die Quelle für die Audioeingabe anzugeben. In diesem Beispiel wird mit AudioConfig.fromDefaultMicrophoneInput() das Standardmikrofon verwendet.

   • Ersetzen Sie die Zeichenfolge YourSubscriptionKey durch ihren Speech-Ressourcenschlüssel, den Sie aus dem Azure-Portal abrufen können.
   • Ersetzen Sie die Zeichenfolge YourServiceRegion durch die mit Ihrer Speech-Ressource verknüpfte Region.

   Hinweis

   Beachten Sie die Liste mit den unterstützten Regionen für Sprach-Assistenten, und stellen Sie sicher, dass Ihre Ressourcen in einer dieser Regionen bereitgestellt werden.

   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. Der ConnectorDialogServiceConnector nutzt mehrere Ereignisse, um Botaktivitäten, Spracherkennungsergebnisse und andere Informationen zu kommunizieren. Fügen Sie daher als Nächstes die folgenden Ereignislistener hinzu:

   // 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. Rufen Sie die Methode connectAsync() auf, um DialogServiceConnector mit Direct Line Speech zu verbinden. Um Ihren Bot zu testen, können Sie die Methode listenOnceAsync aufrufen und eine Audioeingabe von Ihrem Mikrofon senden. Außerdem können Sie die Methode sendActivityAsync verwenden, um eine benutzerdefinierte Aktivität als serialisierte Zeichenfolge zu senden. Diese benutzerdefinierten Aktivitäten können zusätzliche Daten bereitstellen, die Ihr Bot in der Konversation verwendet.

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

7. Speichern Sie die Änderungen an der Datei Main.

8. Zur Unterstützung der Antwortwiedergabe fügen Sie eine zusätzliche Klasse hinzu, die das von der API „getAudio()“ zurückgegebene PullAudioOutputStream-Objekt in ein Java-InputStream-Objekt umwandelt, um die Verarbeitung zu vereinfachen. ActivityAudioStream ist eine spezielle Klasse für die Verarbeitung der Audioantwort aus dem Direct Line Speech-Kanal. Sie stellt Accessoren zum Abrufen von erforderlichen Audioformatinformationen für die Wiedergabe bereit. Wählen Sie dazu Datei>Neu>Klasse aus.

9. Geben Sie im Fenster Neue Java-Klasse die Zeichenfolge speechsdk.quickstart in das Feld Paket und ActivityAudioStream in das Feld Name ein.

10. Öffnen Sie die neu erstellte Klasse ActivityAudioStream, und ersetzen Sie sie durch den folgenden 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. Speichern Sie die Änderungen an der Datei ActivityAudioStream.

Erstellen und Ausführen der App

Drücken Sie F11, oder wählen Sie Ausführen>Debuggen aus. An der Konsole wird „Say something“ (Sagen Sie etwas) angezeigt. Nun können Sie einen englischen Ausdruck oder Satz sprechen, der von Ihrem Bot verstanden wird. Ihre Spracheingabe wird über den Direct Line Speech-Kanal an den Bot übermittelt und vom Bot erkannt und verarbeitet. Die Antwort wird als Aktivität zurückgegeben. Wenn Ihr Bot eine Sprachantwort zurückgibt, erfolgt die Audiowiedergabe unter Verwendung der Klasse AudioPlayer.

Nächste Schritte

Java-Beispiele auf GitHub

Android

Voraussetzungen

Führen Sie die folgenden Schritte aus, bevor Sie beginnen:

• Erstellen einer Speech-Ressource
• Einrichten Ihrer Entwicklungsumgebung und Erstellen eines leeren Projekts
• Erstellen eines Bots, der mit dem Direct Line Speech-Kanal verbunden ist
• Stellen Sie sicher, dass Sie Zugriff auf ein Mikrofon für die Audioaufnahme haben.

Hinweis

Beachten Sie die Liste mit den unterstützten Regionen für Sprach-Assistenten, und stellen Sie sicher, dass Ihre Ressourcen in einer dieser Regionen bereitgestellt werden.

Erstellen und Konfigurieren eines Projekts

Installieren Sie das Speech SDK mithilfe von Android Studio.

Erstellen der Benutzeroberfläche

In diesem Abschnitt erstellen Sie eine einfache Benutzeroberfläche für die Anwendung. Öffnen Sie zunächst die Hauptaktivität: activity_main.xml. Die einfache Vorlage umfasst eine Titelleiste mit den Namen der Anwendung und ein TextView-Element mit der Meldung „Hello World!“.

Ersetzen Sie den Inhalt von activity_main.xml durch folgenden 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>

Dieser XML-Code definiert eine einfache Benutzeroberfläche für die Interaktion mit Ihrem Bot.

• Das button-Element löst eine Interaktion aus und ruft beim Klicken darauf die onBotButtonClicked-Methode auf.
• Das recoText-Element zeigt die Ergebnisse der Spracherkennung, wenn Sie sich mit Ihrem Bot unterhalten.
• Das activityText-Element zeigt die JSON-Nutzlast der neuesten Bot Framework-Aktivität in Ihren Bot.

Der Text und die grafische Darstellung Ihrer Benutzeroberfläche sollten jetzt etwa wie folgt aussehen:

Hinzufügen von Beispielcode

1. Öffnen Sie MainActivity.java, und ersetzen Sie den Inhalt durch den folgenden 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();
                }
            });
        }
    }
   

   • Die onCreate-Methode enthält Code, der Mikrofon- und Internetberechtigungen anfordert.

   • Die Methode onBotButtonClicked ist (wie bereits erwähnt) der Klickhandler für die Schaltfläche. Ein Klick auf die Schaltfläche löst eine einzelne Interaktion („Turn“) mit Ihrem Bot aus.

   • Die registerEventListeners-Methode veranschaulicht die Ereignisse, die vom DialogServiceConnector verwendet werden, und die grundlegende Verarbeitung eingehender Aktivitäten.

2. Ersetzen Sie in der gleichen Datei die Konfigurationszeichenfolgen entsprechend Ihren Ressourcen:

   • Ersetzen Sie YourSpeechSubscriptionKey durch Ihren Abonnementschlüssel.

   • Ersetzen Sie YourServiceRegion durch die Region, die Ihrem Abonnement zugeordnet ist. Nur eine Teilmenge der Regionen des Speech-Diensts wird derzeit mit Direct Line Speech unterstützt. Weitere Informationen finden Sie unter Regionen.

Erstellen und Ausführen der App

1. Verbinden Sie Ihr Android-Gerät mit Ihrem Entwicklungs-PC. Stellen Sie sicher, dass Sie den Entwicklungsmodus und USB-Debuggen für das Gerät aktiviert haben.

2. Um die Anwendung zu erstellen, drücken Sie STRG+F9, oder wählen Sie Erstellen>Projekt erstellen in der Menüleiste aus.

3. Um die Anwendung zu starten, drücken Sie UMSCHALT+F10, oder wählen Sie Ausführen>'App' ausführen aus.

4. Wählen Sie im daraufhin angezeigten Fenster mit Bereitstellungszielen Ihr Android-Gerät aus.

   

Sobald die Anwendung und ihre Aktivität gestartet wurden, klicken Sie auf die Schaltfläche, um mit Ihrem Bot zu sprechen. Während des Gesprächs wird transkribierter Text angezeigt. Die letzte Aktivität, die Sie von Ihrem Bot erhalten haben, wird angezeigt, sobald sie empfangen wird. Wenn Ihr Bot so konfiguriert ist, dass er gesprochene Antworten liefert, wird die Spracherkennung automatisch wiedergegeben.

Nächste Schritte

Java-Beispiele auf GitHub

Sie können sich alle Speech SDK-Go-Beispiele auf GitHub ansehen oder diese herunterladen.

Voraussetzungen

Bevor Sie beginnen:

• Erstellen einer Speech-Ressource
• Einrichten Ihrer Entwicklungsumgebung und Erstellen eines leeren Projekts
• Erstellen eines Bots, der mit dem Direct Line Speech-Kanal verbunden ist
• Stellen Sie sicher, dass Sie Zugriff auf ein Mikrofon für die Audioaufnahme haben.

Hinweis

Beachten Sie die Liste mit den unterstützten Regionen für Sprach-Assistenten, und stellen Sie sicher, dass Ihre Ressourcen in einer dieser Regionen bereitgestellt werden.

Einrichten Ihrer Umgebung

Aktualisieren Sie die go.mod-Datei mit der aktuellsten SDK-Version, indem Sie diese Zeile hinzufügen

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

Beginnen mit Codebausteinen

Ersetzen Sie den Inhalt Ihrer Quelldatei (z. B. quickstart.go) durch den Inhalt unten, der Folgendes beinhaltet:

• Die „main“-Paketdefinition
• Das Importieren der erforderlichen Module aus dem Speech SDK
• Variablen zum Speichern der Botinformationen, die später in dieser Schnellstartanleitung ersetzt werden
• Eine einfache Implementierung, bei der das Mikrofon für die Audioeingabe verwendet wird
• Ereignishandler für verschiedene Ereignisse, die während einer Sprachinteraktion stattfinden

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)
}

Ersetzen Sie die Werte YOUR_SUBSCRIPTION_KEY und YOUR_BOT_REGION durch tatsächliche Werte aus der Speech-Ressource.

• Navigieren Sie zum Azure-Portal, und öffnen Sie Ihre Speech-Ressource.

• Auf der linken Seite sehen Sie unter Schlüssel und Endpunkt zwei verfügbare Abonnementschlüssel.

  • Ersetzen Sie mit einem davon den Wert YOUR_SUBSCRIPTION_KEY.

• Sehen Sie sich auf der linken Seite unter Übersicht die Region an, und ordnen Sie sie dem Regionsbezeichner zu.

  • Verwenden Sie den Regionsbezeichner als Ersatz für den Wert YOUR_BOT_REGION, z. B. "westus" für USA, Westen.

  Hinweis

  Beachten Sie die Liste mit den unterstützten Regionen für Sprach-Assistenten, und stellen Sie sicher, dass Ihre Ressourcen in einer dieser Regionen bereitgestellt werden.

  Hinweis

  Informationen zum Konfigurieren Ihres Bots finden Sie in der Bot Framework-Dokumentation zum Direct Line Speech-Kanal.

Erläuterung zum Code

Für die Erstellung eines Sprachkonfigurationsobjekts sind der Speech-Abonnementschlüssel und die Region erforderlich. Das Konfigurationsobjekt wird zum Instanziieren eines Spracherkennungsobjekts benötigt.

Die Erkennungsinstanz bietet mehrere Spracherkennungsmöglichkeiten. In diesem Beispiel wird Sprache fortlaufend erkannt. Durch diese Funktion wird dem Speech-Dienst mitgeteilt, dass Sie viele Ausdrücke zur Erkennung senden, und wann das Programm beendet wird und die Spracherkennung einstellt. Erzielte Ergebnisse werden vom Code in die Konsole geschrieben.

Erstellen und Ausführen

Sie sind jetzt so weit, Ihr Projekt zu erstellen und den benutzerdefinierten Sprachassistenten mit dem Speech-Dienst zu testen.

1. Erstellen Sie Ihr Projekt, beispielsweise mit „go build“
2. Führen Sie das Modul aus, und sprechen Sie einen Ausdruck oder einen Satz in das Mikrofon Ihres Geräts. Ihre Spracheingabe wird an den Direct Line Speech-Kanal übermittelt, in Text transkribiert und als Ausgabe angezeigt.

Hinweis

Das Speech SDK verwendet für die Erkennung standardmäßig amerikanisches Englisch (en-us). Informationen zum Auswählen der Ausgangssprache finden Sie unter Erkennen von Sprache.

Nächste Schritte

Go-Beispiele auf GitHub durchsuchen

Zusätzliche Sprach- und Plattformunterstützung

Wenn Sie auf diese Registerkarte geklickt haben, wurde wahrscheinlich keine Schnellstartanleitung für Ihre bevorzugte Programmiersprache angezeigt. Keine Sorge, auf GitHub gibt es weitere Schnellstartanleitungen und Codebeispiele. Verwenden Sie die Tabelle, um das richtige Beispiel für Ihre Programmiersprache und die Kombination aus Plattform und Betriebssystem zu finden.

Sprache	Codebeispiele
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