Freigeben über


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:

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.

    Beispielanwendung für einen UWP-Sprachassistenten in C#: Schnellstart

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

    Berechtigungsanforderung für den Mikrofonzugriff

  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


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

Auswählen Ihrer Zielumgebung

Voraussetzungen

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

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.

    Screenshot des Fensters „Neue Java-Klasse“

  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.

Screenshot der Konsolenausgabe nach erfolgreicher Erkennung

Nächste Schritte

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

Voraussetzungen

Bevor Sie beginnen:

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

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
C++ Windows, Linux, macOS
Java Android, JRE
JavaScript Browser, Node.js
Objective-C iOS, macOS
Python Windows, Linux, macOS
Swift iOS, macOS