Rychlý start: Vytvoření vlastního hlasového asistenta

V tomto rychlém startu pomocí sady Speech SDK vytvoříte vlastní aplikaci hlasového asistenta, která se připojí k robotovi, kterého jste už vytvořili a nakonfigurovali. Pokud potřebujete vytvořit robota, přečtěte si související kurz s podrobnějším průvodcem.

Po splnění několika požadavků provede připojení vlastního hlasového asistenta jenom několik kroků:

  • Vytvořte BotFrameworkConfig objekt z klíče předplatného a oblasti.
  • Vytvořte DialogServiceConnector objekt pomocí objektu BotFrameworkConfig výše.
  • Pomocí objektu DialogServiceConnector spusťte proces naslouchání pro jednu promluvu.
  • Zkontrolujte vrácenou.ActivityReceivedEventArgs

Poznámka

Sada Speech SDK pro C++, JavaScript, Objective-C, Python a Swift podporují vlastní hlasové asistenty, ale zatím jsme tu nezahrnuli průvodce.

Na GitHub si můžete zobrazit nebo stáhnout všechny ukázky sady Speech SDK C#.

Požadavky

Než začnete, nezapomeňte:

Poznámka

Projděte si seznam podporovaných oblastí pro hlasové asistenty a ujistěte se, že jsou vaše prostředky nasazené v jedné z těchto oblastí.

Otevření projektu v Visual Studio

Prvním krokem je ujistit se, že máte projekt otevřený v Visual Studio.

Začněte s některým často používaným kódem.

Pojďme přidat kód, který pro náš projekt funguje jako kostra.

  1. V Průzkumník řešení otevřete MainPage.xaml.

  2. V zobrazení XAML návrháře nahraďte celý obsah následujícím fragmentem kódu, který definuje základní uživatelské rozhraní:

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

Návrhové zobrazení se aktualizuje, aby se zobrazilo uživatelské rozhraní aplikace.

  1. V Průzkumník řešení otevřete zdrojový soubor MainPage.xaml.csza kódem . (Seskupuje se pod MainPage.xaml.) Obsah tohoto souboru nahraďte následujícím kódem, který zahrnuje:
  • using příkazy pro obory Speech názvů a Speech.Dialog obory názvů

  • Jednoduchá implementace pro zajištění přístupu k mikrofonu, kabelového připojení k obslužné rutině tlačítka

  • Základní pomocné rutiny uživatelského rozhraní k prezentování zpráv a chyb v aplikaci

  • Cílový bod pro inicializační cestu kódu, která se naplní později

  • Pomocná rutina pro přehrání textu na řeč (bez podpory streamování)

  • Obslužná rutina prázdného tlačítka pro zahájení naslouchání, která se naplní později.

    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. Do textu InitializeDialogServiceConnectormetody přidejte následující fragment kódu . Tento kód vytvoří DialogServiceConnector informace o vašem předplatném.

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

    Poznámka

    Projděte si seznam podporovaných oblastí pro hlasové asistenty a ujistěte se, že jsou vaše prostředky nasazené v jedné z těchto oblastí.

    Poznámka

    Informace o konfiguraci robota najdete v dokumentaci ke službě Bot Framework pro kanál služby Direct Line Speech.

  2. Nahraďte řetězce YourSpeechSubscriptionKey a YourServiceRegion vlastními hodnotami pro vaše předplatné a oblast služby Speech.

  3. Připojte následující fragment kódu na konec těla InitializeDialogServiceConnectormetody . Tento kód nastaví obslužné rutiny pro události, které DialogServiceConnector se spoléhají na komunikaci aktivit robota, výsledků rozpoznávání řeči a dalších informací.

    // 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. Do textu ListenButton_ButtonClicked metody ve MainPage třídě přidejte následující fragment kódu. Tento kód se nastaví DialogServiceConnector tak, aby naslouchal, protože jste už nastavili konfiguraci a zaregistrovali obslužné rutiny událostí.

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

Sestavit a spustit aplikaci

Teď jste připraveni vytvořit aplikaci a otestovat vlastního hlasového asistenta pomocí služby Speech.

  1. Na řádku nabídek zvolte BuildBuild Solution (Sestavení> řešení) a sestavte aplikaci. Kód by se teď měl zkompilovat bez chyb.

  2. Aplikaci spustíte tak, že zvolíte ladění DebugStart> (nebo stisknete klávesu F5). Zobrazí se okno helloworld .

    Sample UWP voice assistant application in C# - quickstart

  3. Vyberte Povolit mikrofon a až se zobrazí žádost o přístup k oprávnění, vyberte Ano.

    Microphone access permission request

  4. Vyberte Možnost Mluvit s robotem a mluvte anglickou frázi nebo větu do mikrofonu zařízení. Vaše řeč se přenese do kanálu Direct Line Speech a přepíše se na text, který se zobrazí v okně.

Další kroky


Na GitHub si můžete zobrazit nebo stáhnout všechny ukázky sady Speech SDK v Javě.

Volba cílového prostředí

Požadavky

Než začnete, nezapomeňte:

Poznámka

Projděte si seznam podporovaných oblastí pro hlasové asistenty a ujistěte se, že jsou vaše prostředky nasazené v jedné z těchto oblastí.

Vytvoření a konfigurace projektu

  1. Spusťte Eclipse.

  2. Ve spouštěči Eclipse zadejte do pole Pracovní prostor název nového adresáře pracovního prostoru. Potom vyberte Launch (Spustit).

    Screenshot of Eclipse Launcher.

  3. Za chvíli se zobrazí hlavní okno prostředí Eclipse IDE. Zavřete úvodní obrazovku, pokud je k dispozici.

  4. Na řádku nabídek Eclipse vytvořte nový projekt tak, že vyberete FileNew>> Project.

  5. Zobrazí se dialogové okno Nový Project. Vyberte Java Project a pak vyberte Další.

    Screenshot of the New Project dialog, with Java Project highlighted.

  6. Spustí se průvodce novým Project Javy. Do pole s názvem Project zadejte rychlý start. Jako spouštěcí prostředí zvolte JavaSE-1.8 . Vyberte Dokončit.

    Screenshot of the New Java Project wizard, with selections for creating a Java project.

  7. Pokud se zobrazí okno Open Associated Perspective? (Otevřít související perspektivu?), vyberte Open Perspective (Otevřít perspektivu).

  8. V Průzkumníku balíčků klikněte pravým tlačítkem myši na projekt rychlý start . V místní nabídce vyberte ConfigureConvert>to Maven Project.

    Screenshot of Package Explorer and the commands for converting to a Maven project.

  9. Zobrazí se okno Create new POM (Vytvořit nový POM). Do pole ID skupiny zadejte com.microsoft.cognitiveservices.speech.samples. Do pole ID artefaktu zadejte rychlý start. Pak vyberte Dokončit.

    Screenshot of the window for creating a new POM.

  10. Otevřete souborpom.xml a upravte ho:

    • Na konci souboru před pravou značkou </project>vytvořte repositories prvek s odkazem na úložiště Maven pro sadu Speech SDK:

      <repositories>
        <repository>
          <id>maven-cognitiveservices-speech</id>
          <name>Microsoft Cognitive Services Speech Maven Repository</name>
          <url>https://csspeechstorage.blob.core.windows.net/maven/</url>
        </repository>
      </repositories>
      
    • dependencies Přidejte element se sadou Speech SDK verze 1.21.0 jako závislost:

      <dependencies>
        <dependency>
          <groupId>com.microsoft.cognitiveservices.speech</groupId>
          <artifactId>client-sdk</artifactId>
          <version>1.21.0</version>
        </dependency>
      </dependencies>
      
    • Uložte změny.

Pokud chcete povolit protokolování, aktualizujte soubor pom.xml tak, aby zahrnoval následující závislost:

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

Přidání ukázkového kódu

  1. Pokud chcete do projektu Java přidat novou prázdnou třídu, vyberte FileNewClass>>.

  2. V okně Nová třída Java zadejte speechsdk.quickstart do pole Balíček a Main v poli Název .

    Screenshot of New Java Class window

  3. Otevřete nově vytvořenou Main třídu a nahraďte obsah Main.java souboru následujícím počátečním kódem:

    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. main V metodě nejprve nakonfigurujete DialogServiceConfig a použijete ji k vytvoření DialogServiceConnector instance. Tato instance se připojí k kanálu Direct Line Speech pro interakci s robotem. Instance AudioConfig se také používá k určení zdroje pro zvukový vstup. V tomto příkladu se používá AudioConfig.fromDefaultMicrophoneInput()výchozí mikrofon s .

    • Nahraďte řetězec YourSubscriptionKey klíčem předplatného, který můžete získat z tohoto webu.
    • Nahraďte řetězec YourServiceRegionoblastí přidruženou k vašemu předplatnému.

    Poznámka

    Pro hlasové asistenty si projděte seznam podporovaných oblastí a ujistěte se, že jsou vaše prostředky nasazené v jedné z těchto oblastí.

    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. Konektor DialogServiceConnector spoléhá na několik událostí ke komunikaci aktivit robota, výsledků rozpoznávání řeči a dalších informací. Přidejte další naslouchací procesy událostí.

    // 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. DialogServiceConnector Připojení k Direct Line Speech vyvoláním connectAsync() metody. Pokud chcete robota otestovat, můžete vyvolat metodu listenOnceAsync pro odesílání zvukového vstupu z mikrofonu. Kromě toho můžete použít také metodu sendActivityAsync k odeslání vlastní aktivity jako serializovaného řetězce. Tyto vlastní aktivity můžou poskytovat další data, která robot používá v konverzaci.

    connector.connectAsync();
    // Start listening.
    System.out.println("Say something ...");
    connector.listenOnceAsync();
    
    // connector.sendActivityAsync(...)
    
  7. Uložte změny do Main souboru.

  8. Chcete-li podporovat přehrávání odpovědí, přidejte další třídu, která transformuje PullAudioOutputStream objekt vrácený z rozhraní getAudio() API na Java InputStream pro usnadnění zpracování. Toto ActivityAudioStream je specializovaná třída, která zpracovává zvukovou odpověď z kanálu Direct Line Speech. Poskytuje přístupové objekty k načtení informací o formátu zvuku, které jsou potřeba pro zpracování přehrávání. V takovém případě vyberte FileNewClass>>.

  9. V okně Nová třída Java zadejte speechsdk.quickstart do pole Balíček a ActivityAudioStream do pole Název .

  10. Otevřete nově vytvořenou ActivityAudioStream třídu a nahraďte ji následujícím kódem:

    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. Uložte změny do ActivityAudioStream souboru.

Sestavte a spusťte aplikaci.

Vyberte F11 nebo vyberte SpustitDebug>. Konzola zobrazí zprávu "Řekněte něco". V tomto okamžiku mluvte anglickou frázi nebo větu, kterou může robot pochopit. Vaše řeč se přenáší do robota prostřednictvím kanálu Direct Line Speech, kde je rozpoznán a zpracován robotem. Odpověď se vrátí jako aktivita. Pokud robot vrátí řeč jako odpověď, zvuk se přehraje pomocí AudioPlayer třídy.

Screenshot of console output after successful recognition

Další kroky

Na GitHub si můžete zobrazit nebo stáhnout všechny ukázky go sady Speech SDK.

Požadavky

Než začnete:

Poznámka

Projděte si seznam podporovaných oblastí pro hlasové asistenty a ujistěte se, že jsou vaše prostředky nasazené v jedné z těchto oblastí.

Nastavení vašeho prostředí

Přidáním tohoto řádku aktualizujte soubor go.mod nejnovější verzí sady SDK.

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

Začněte s některým často používaným kódem.

Nahraďte obsah vašeho zdrojového souboru (např. quickstart.go) následujícím kódem, který zahrnuje:

  • Definice balíčku "main"
  • import potřebných modulů ze sady Speech SDK
  • proměnné pro ukládání informací o robotovi, které budou nahrazeny později v tomto rychlém startu
  • jednoduchá implementace pomocí mikrofonu pro zvukový vstup
  • obslužné rutiny událostí pro různé události, které probíhají během interakce řeči
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)
}

YOUR_SUBSCRIPTION_KEY Nahraďte hodnoty YOUR_BOT_REGION skutečnými hodnotami z prostředku služby Speech.

  • Přejděte na Azure Portal a otevřete prostředek služby Speech.

  • V části Klíče a koncový bod vlevo jsou k dispozici dva dostupné klíče předplatného.

    • Jako náhradu YOUR_SUBSCRIPTION_KEY hodnoty použijte jednu z těchto hodnot.
  • V části Přehled na levé straně si poznamenejte oblast a namapujte ji na identifikátor oblasti.

    • Jako náhradu YOUR_BOT_REGION hodnoty použijte identifikátor oblasti, například: "westus" pro USA – západ

    Poznámka

    Projděte si seznam podporovaných oblastí pro hlasové asistenty a ujistěte se, že jsou vaše prostředky nasazené v jedné z těchto oblastí.

    Poznámka

    Informace o konfiguraci robota najdete v dokumentaci ke službě Bot Framework pro kanál služby Direct Line Speech.

Vysvětlení kódu

K vytvoření objektu konfigurace řeči se vyžaduje klíč předplatného služby Speech a oblast. Objekt konfigurace je potřeba k vytvoření instance objektu rozpoznávání řeči.

Instance rozpoznávání zveřejňuje několik způsobů rozpoznávání řeči. V tomto příkladu je řeč nepřetržitě rozpoznána. Tato funkce umožňuje službě Speech vědět, že odesíláte mnoho frází pro rozpoznávání a kdy program ukončí rozpoznávání řeči. Jakmile se zobrazí výsledky, kód je zapíše do konzoly.

Sestavení a spuštění

Teď jste nastavili sestavení projektu a otestování vlastního hlasového asistenta pomocí služby Speech.

  1. Sestavení projektu, například "go build"
  2. Spusťte modul a mluvte frázi nebo větu do mikrofonu zařízení. Vaše řeč se přenese do kanálu Direct Line Speech a přepíše se na text, který se zobrazí jako výstup.

Poznámka

Sada Speech SDK ve výchozím nastavení rozpozná použití en-us pro jazyk, viz Určení zdrojového jazyka pro převod řeči na text , kde najdete informace o výběru zdrojového jazyka.

Další kroky

Další podpora jazyků a platforem

Pokud jste klikli na tuto kartu, pravděpodobně jste ve svém oblíbeném programovacím jazyce neviděli rychlý start. Nemějte obavy, máme k dispozici další materiály pro rychlý start a ukázky kódu na GitHub. Pomocí tabulky najděte správnou ukázku pro vaši kombinaci programovacího jazyka a platformy/operačního systému.

Jazyk Ukázky kódů
C# .NET Framework, .NET Core, UPW, Unity, Xamarin
C++ Windows, Linux, macOS
Java Android, JRE
JavaScript Prohlížeč, Node.js
Objective-C iOS, macOS
Python Windows, Linux, macOS
Swift iOS, macOS