Hızlı Başlangıç: Özel ses yardımcı oluşturma

Bu hızlı başlangıçta Konuşma SDK'sını kullanarak önceden oluşturup yapılandırdığınız bir bota bağlanan özel bir ses yardımcı uygulaması oluşturacaksınız. Bot oluşturmanız gerekiyorsa daha kapsamlı bir kılavuz için ilgili öğreticiye bakın.

Birkaç önkoşulu karşıladıktan sonra özel ses yardımcı bağlama işlemi yalnızca birkaç adımdan oluşur:

• Abonelik anahtarınızdan ve bölgenizden bir BotFrameworkConfig nesne oluşturun.
• Yukarıdaki nesnesini kullanarak BotFrameworkConfig bir DialogServiceConnector nesnesi oluşturun.
• DialogServiceConnector nesnesini kullanarak tek bir konuşma için dinleme işlemini başlatın.
• Döndürüleni ActivityReceivedEventArgs inceleyin.

Not

C++, JavaScript, Objective-C, Python ve Swift için Konuşma SDK'sı özel sesli yardımcıları destekler, ancak buraya henüz bir kılavuz eklemedik.

GitHub'da tüm Konuşma SDK'sı C# Örneklerini görüntüleyebilir veya indirebilirsiniz.

Önkoşullar

Başlamadan önce şunları yaptığınızdan emin olun:

• Konuşma kaynağı oluşturma
• Geliştirme ortamınızı ayarlama ve boş bir proje oluşturma
• Direct Line Konuşma kanalına bağlı bir bot oluşturma
• Ses yakalama için bir mikrofona erişiminiz olduğundan emin olun

Not

Sesli yardımcılar için desteklenen bölgelerin listesine bakın ve kaynaklarınızın bu bölgelerden birinde dağıtıldığından emin olun.

Projenizi Visual Studio'da açma

İlk adım, projenizin Visual Studio'da açık olduğundan emin olmaktır.

Bazı ortak kodlarla başlayın

Şimdi projemiz için iskelet olarak çalışan bazı kodlar ekleyelim.

1. Çözüm Gezgini'da dosyasını açınMainPage.xaml.

2. Tasarımcının XAML görünümünde tüm içeriği, temel kullanıcı arabirimini tanımlayan aşağıdaki kod parçacığıyla değiştirin:

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

Tasarım görünümü, uygulamanın kullanıcı arabirimini gösterecek şekilde güncelleştirilir.

1. Çözüm Gezgini'da arka planda kod kaynak dosyasını MainPage.xaml.csaçın. (altında MainPage.xamlgruplandırılır.) Bu dosyanın içeriğini aşağıdakileri içeren aşağıdakiyle değiştirin:

• usingve Speech.Dialog ad alanları için Speech deyimler

• Mikrofon erişimini sağlamak için bir düğme işleyiciye kablolu basit bir uygulama

• Uygulamada iletileri ve hataları sunmak için temel kullanıcı arabirimi yardımcıları

• Başlatma kodu yolu için daha sonra doldurulacak bir giriş noktası

• Metin okuma (akış desteği olmadan) oynatmak için bir yardımcı

• Dinlemeye başlamak için daha sonra doldurulacak boş bir düğme işleyicisi

  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. Aşağıdaki kod parçacığını yönteminin gövdesine InitializeDialogServiceConnectorekleyin. Bu kod, abonelik bilgilerinizle öğesini DialogServiceConnector oluşturur.

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

   Not

   Sesli yardımcılar için desteklenen bölgelerin listesine bakın ve kaynaklarınızın bu bölgelerden birinde dağıtıldığından emin olun.

   Not

   Botunuzu yapılandırma hakkında bilgi için Direct Line Konuşma kanalı için Bot Framework belgelerine bakın.

2. konuşma aboneliğiniz ve bölgeniz için dizeleri YourSpeechSubscriptionKey ve YourServiceRegion değerlerini kendi değerlerinizle değiştirin.

3. Aşağıdaki kod parçacığını yönteminin gövdesinin InitializeDialogServiceConnectorsonuna ekleyin. Bu kod, bot etkinliklerini, konuşma tanıma sonuçlarını ve diğer bilgileri iletmek için tarafından DialogServiceConnector temel alınan olaylar için işleyiciler ayarlar.

   // 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. Sınıfındaki yönteminin gövdesine ListenButton_ButtonClicked aşağıdaki kod parçacığını MainPage ekleyin. Yapılandırmayı önceden oluşturduğunuz ve olay işleyicilerini kaydettiğiniz için bu kod dinlemeye ayarlanmıştır DialogServiceConnector .

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

Uygulamanızı oluşturup çalıştırın

Artık Konuşma hizmetini kullanarak uygulamanızı oluşturmaya ve özel ses yardımcı test etmeye hazırsınız.

1. Menü çubuğundanDerleme ÇözümüOluştur'u> seçerek uygulamayı derleyin. Kodun artık hatasız derlenmesi gerekir.

2. Uygulamayı başlatmak için Hata Ayıklamayı>Başlat Hata Ayıklama'yı seçin (veya F5 tuşuna basın). Helloworld penceresi görüntülenir.

   

3. Mikrofonu Etkinleştir'i seçin ve erişim izni isteği görüntülendiğinde Evet'i seçin.

   

4. Botunuzla konuş'u seçin ve cihazınızın mikrofonuna İngilizce bir ifade veya cümle söyleyin. Konuşmanız Direct Line Konuşma kanalına iletilir ve pencerede görünen metne dönüştürülür.

Sonraki adımlar

GitHub'da C# örneklerini keşfetme

---

GitHub'da tüm Konuşma SDK'sı Java Örneklerini görüntüleyebilir veya indirebilirsiniz.

Hedef ortamınızı seçin

Java Çalışma Zamanı

Önkoşullar

Başlamadan önce şunları yaptığınızdan emin olun:

• Konuşma kaynağı oluşturma
• Geliştirme ortamınızı ayarlama ve boş bir proje oluşturma
• Direct Line Konuşma kanalına bağlı bir bot oluşturma
• Ses yakalama için bir mikrofona erişiminiz olduğundan emin olun

Not

Sesli yardımcılar için desteklenen bölgelerin listesine bakın ve kaynaklarınızın bu bölgelerden birinde dağıtıldığından emin olun.

Proje oluşturma ve yapılandırma

Eclipse projesi oluşturun ve Konuşma SDK'sını yükleyin.

Ayrıca, günlüğe kaydetmeyi etkinleştirmek için pom.xml dosyasını aşağıdaki bağımlılığı içerecek şekilde güncelleştirin:

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

Örnek kod ekleme

1. Java projenize yeni boş bir sınıf eklemek için Dosya>Yeni>Sınıf'ı seçin.

2. Yeni Java Sınıfı penceresinde Paket alanına speechsdk.quickstart ve Ad alanına Main yazın.

   

3. Yeni oluşturulan Main sınıfı açın ve dosyanın içeriğini Main.java aşağıdaki başlangıç koduyla değiştirin:

   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. yönteminde main önce öğesini DialogServiceConfig yapılandırıp bir DialogServiceConnector örnek oluşturmak için kullanırsınız. Bu örnek, botunuzla etkileşim kurmak için Direct Line Konuşma kanalına bağlanır. Örnek AudioConfig ayrıca ses girişinin kaynağını belirtmek için de kullanılır. Bu örnekte, varsayılan mikrofon ile AudioConfig.fromDefaultMicrophoneInput()kullanılır.

   • dizesini YourSubscriptionKey, Azure portal alabileceğiniz Konuşma kaynak anahtarınızla değiştirin.
   • dizesini YourServiceRegion Konuşma kaynağınızla ilişkilendirilmiş bölgeyle değiştirin.

   Not

   Sesli yardımcılar için desteklenen bölgelerin listesine bakın ve kaynaklarınızın bu bölgelerden birinde dağıtıldığından emin olun.

   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. Bağlayıcı DialogServiceConnector bot etkinliklerini, konuşma tanıma sonuçlarını ve diğer bilgileri iletmek için çeşitli olaylara dayanır. Bu olay dinleyicilerini ekleyin.

   // 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. yöntemini çağırarak Direct Line Konuşma'ya bağlanın DialogServiceConnectorconnectAsync(). Botunuzu test etmek için yöntemini çağırarak listenOnceAsync mikrofonunuzdan ses girişi gönderebilirsiniz. Ayrıca, bir özel etkinliği serileştirilmiş dize olarak göndermek için yöntemini de kullanabilirsiniz sendActivityAsync . Bu özel etkinlikler botunuzun konuşmada kullandığı ek veriler sağlayabilir.

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

7. Değişiklikleri dosyaya Main kaydedin.

8. Yanıt kayıttan yürütmeyi desteklemek için getAudio() API'sinden döndürülen PullAudioOutputStream nesnesini işleme kolaylığı için Java InputStream'e dönüştüren ek bir sınıf ekleyin. BuActivityAudioStream, Direct Line Konuşma kanalından gelen ses yanıtını işleyen özel bir sınıftır. Kayıttan yürütmeyi işlemek için gereken ses biçimi bilgilerini getirmek için erişimciler sağlar. Bunun için Dosya>Yeni Sınıf'ı> seçin.

9. Yeni Java Sınıfı penceresinde Paket alanına speechsdk.quickstart ve Ad alanına ActivityAudioStream yazın.

10. Yeni oluşturulan ActivityAudioStream sınıfı açın ve aşağıdaki kodla değiştirin:

    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. Değişiklikleri dosyaya ActivityAudioStream kaydedin.

Uygulamayı derleyin ve çalıştırın

F11'i veyaHata AyıklamayıÇalıştır'ı> seçin. Konsolda "Bir şey söyle" iletisi görüntülenir. Bu noktada, botunuzun anlayabileceği İngilizce bir tümcecik veya cümle söyleyin. Konuşmanız botunuz tarafından tanındığı ve işlendiği Direct Line Konuşma kanalı üzerinden botunuza iletilir. Yanıt bir etkinlik olarak döndürülür. Botunuz yanıt olarak konuşma döndürüyorsa, sınıfı kullanılarak AudioPlayer ses oynatılır.

Sonraki adımlar

GitHub'da Java örneklerini keşfetme

Android

Önkoşullar

Başlamadan önce şunları yaptığınızdan emin olun:

• Konuşma kaynağı oluşturma
• Geliştirme ortamınızı ayarlama ve boş bir proje oluşturma
• Direct Line Konuşma kanalına bağlı bir bot oluşturma
• Ses yakalama için bir mikrofona erişiminiz olduğundan emin olun

Not

Sesli yardımcılar için desteklenen bölgelerin listesine bakın ve kaynaklarınızın bu bölgelerden birinde dağıtıldığından emin olun.

Projeyi oluşturma ve yapılandırma

Android Studio kullanarak Konuşma SDK'sını yükleyin.

Kullanıcı arabirimi oluşturma

Bu bölümde, uygulama için temel bir kullanıcı arabirimi (UI) oluşturacağız. Başlangıç olarak ana etkinliği açalım: activity_main.xml. Temel şablon, uygulamanın adını içeren bir başlık çubuğu ve "Merhaba dünya!" iletisini içeren bir TextView başlık çubuğu içerir.

Ardından öğesinin activity_main.xml içeriğini aşağıdaki kodla değiştirin:

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

Bu XML, botunuzla etkileşime geçmek için basit bir kullanıcı arabirimi tanımlar.

• button öğesi bir etkileşim başlatır ve tıklandığında yöntemini çağırıronBotButtonClicked.
• Botunuzla recoText konuşurken öğe konuşmayı metne dönüştürme sonuçlarını görüntüler.
• öğesi, activityText botunuzdan en son Bot Framework etkinliği için JSON yükünü görüntüler.

Kullanıcı arabiriminizin metin ve grafik gösterimi artık şöyle görünmelidir:

Örnek kod ekleme

1. öğesini açın MainActivity.javave içeriğini aşağıdaki kodla değiştirin:

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

   • yöntemi, onCreate mikrofon ve internet izinleri isteyen kodu içerir.

   • onBotButtonClicked yöntemi daha önce de belirtildiği gibi düğme tıklama işleyicisidir. Düğmeye basıldığında botunuzla tek bir etkileşim ("dönüş") tetikler.

   • yöntemi, registerEventListeners ve gelen etkinliklerin temel işlemesi tarafından DialogServiceConnector kullanılan olayları gösterir.

2. Aynı dosyada yapılandırma dizelerini kaynaklarınızla eşleşecek şekilde değiştirin:

   • YourSpeechSubscriptionKey değerini abonelik anahtarınızla değiştirin.

   • değerini aboneliğinizle ilişkilendirilmiş bölgeyle değiştirin YourServiceRegion Konuşma hizmeti bölgelerinin yalnızca bir alt kümesi şu anda Direct Line Konuşma ile desteklenmektedir. Daha fazla bilgi için bkz. bölgeler.

Uygulamayı derleyin ve çalıştırın

1. Android cihazınızı geliştirme bilgisayarınıza bağlayın. Cihazda geliştirme modunu ve USB hata ayıklamasını etkinleştirdiğinizden emin olun.

2. Uygulamayı oluşturmak için Ctrl+F9 tuşlarına basın veya menü çubuğundan Proje Oluştur'u> seçin.

3. Uygulamayı başlatmak için Shift+F10 tuşlarına basın veya Çalıştır>'uygulama' çalıştır'ı seçin.

4. Görüntülenen dağıtım hedefi penceresinde Android cihazınızı seçin.

   

Uygulama ve etkinliği başlatıldıktan sonra botunuzla konuşmaya başlamak için düğmeye tıklayın. Siz konuşurken dökümü alınmış metin görünür ve botunuzdan aldığınız en son etkinlik alındığında görünür. Botunuz sesli yanıtlar sağlayacak şekilde yapılandırıldıysa, konuşmayı metne dönüştürme otomatik olarak yürütülecektir.

Sonraki adımlar

GitHub'da Java örneklerini keşfetme

GitHub'da tüm Konuşma SDK'sı Go Örneklerini görüntüleyebilir veya indirebilirsiniz.

Önkoşullar

Başlamadan önce:

• Konuşma kaynağı oluşturma
• Geliştirme ortamınızı ayarlama ve boş proje oluşturma
• Direct Line Konuşma kanalına bağlı bir bot oluşturma
• Ses yakalama için bir mikrofona erişiminiz olduğundan emin olun

Not

Sesli yardımcılar için desteklenen bölgelerin listesine bakın ve kaynaklarınızın bu bölgelerden birinde dağıtıldığından emin olun.

Ortamınızı ayarlama

Bu satırı ekleyerek go.mod dosyasını en son SDK sürümüyle güncelleştirin

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

Bazı ortak kodlarla başlayın

Kaynak dosyanızın içeriğini (örn. quickstart.go) aşağıdakileri içeren aşağıdakiyle değiştirin:

• "main" paket tanımı
• Konuşma SDK'sından gerekli modülleri içeri aktarma
• bu hızlı başlangıcın ilerleyen bölümlerinde değiştirilecek bot bilgilerini depolamaya yönelik değişkenler
• ses girişi için mikrofon kullanan basit bir uygulama
• konuşma etkileşimi sırasında gerçekleşen çeşitli olaylar için olay işleyicileri

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 ve YOUR_BOT_REGION değerlerini Konuşma kaynağındaki gerçek değerlerle değiştirin.

• Azure portal gidin ve Konuşma kaynağınızı açın

• Sol taraftaki Anahtarlar ve Uç Nokta'nın altında iki kullanılabilir abonelik anahtarı vardır

  • Değer değişimi olarak YOUR_SUBSCRIPTION_KEY birini kullanın

• Sol taraftaki Genel Bakış'ın altında bölgeyi not edin ve bölge tanımlayıcısına eşleyin

  • Değer değişimi olarak Bölge tanımlayıcısını YOUR_BOT_REGION kullanın, örneğin: "westus"Batı ABD için

  Not

  Sesli yardımcılar için desteklenen bölgelerin listesine bakın ve kaynaklarınızın bu bölgelerden birinde dağıtıldığından emin olun.

  Not

  Botunuzu yapılandırma hakkında bilgi için Direct Line Konuşma kanalı için Bot Framework belgelerine bakın.

Kod açıklaması

Konuşma yapılandırma nesnesi oluşturmak için Konuşma abonelik anahtarı ve bölgesi gereklidir. Konuşma tanıma nesnesinin örneğini oluşturmak için yapılandırma nesnesi gereklidir.

Tanıyıcı örneği, konuşmayı tanımanın birden çok yolunu gösterir. Bu örnekte konuşma sürekli olarak tanınır. Bu işlev Konuşma hizmetinin tanıma için birçok tümcecik gönderdiğinizi bilmesini sağlar ve program konuşmayı tanımayı durdurmak için sonlandırıldığında. Sonuçlar elde edildikçe kod bunları konsola yazar.

Derleme ve çalıştırma

Artık projenizi derlemek ve Konuşma hizmetini kullanarak özel ses yardımcı test etmek için ayarlandınız.

1. Projenizi oluşturun, örneğin "go build"
2. Modülü çalıştırın ve cihazınızın mikrofonuna bir tümcecik veya cümle söyleyin. Konuşmanız Direct Line Konuşma kanalına iletilir ve çıkış olarak görünen metne dönüştürülür.

Not

Konuşma SDK'sı varsayılan olarak dil için en-us kullanarak tanımayı kabul eder. Kaynak dili seçme hakkında bilgi için bkz. Konuşmayı tanıma .

Sonraki adımlar

GitHub'da Go örneklerini keşfetme

Ek dil ve platform desteği

Bu sekmeye tıkladıysanız, büyük olasılıkla en sevdiğiniz programlama dilinde bir hızlı başlangıç görmediniz. Endişelenmeyin, GitHub'da ek hızlı başlangıç malzemeleri ve kod örnekleri mevcuttur. Programlama diliniz ve platform/işletim sistemi bileşiminiz için doğru örneği bulmak için tabloyu kullanın.

Dil	Kod örnekleri
C#	.NET Framework, .NET Core, UWP, Unity, Xamarin
C++	Windows, Linux, macOS
Java	Android, JRE
JavaScript	Tarayıcı, Node.js
Objective-C	iOS, macOS
Python	Windows, Linux, macOS
Swift	iOS, macOS