private async Task InitializeItemRecognizer()
{
CleanupItemRecognizer();
try
{
this.itemRecognizer = new SpeechRecognizer(lang);
this.itemRecognizer.StateChanged += ItemRecognizerStateChanged;
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
this.itemRecognizer.Constraints.Add(dictationConstraint);
var result = await itemRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
this.SetDebugMessage("Grammar Compilation Failed: " + result.Status.ToString());
}
this.itemRecognizer.StateChanged += ItemRecognizerStateChanged;
this.itemRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;;
this.itemRecognizer.ContinuousRecognitionSession.ResultGenerated += OnItemRecognizerResult;
}
catch (Exception ex)
{
// TODO: handle speech initialization errors
this.SetDebugMessage(ex.Message);
}
}
private async void InitializeSpeechRecognizer()
{
try
{
if (speechRecognizer != null)
{
speechRecognizer.RecognizeAsync().Cancel();
speechRecognizer.RecognizeAsync().Close();
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
speechRecognizer = new SpeechRecognizer();
var topicConstraing = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
speechRecognizer.Constraints.Add(topicConstraing);
await speechRecognizer.CompileConstraintsAsync();
this.Operation = await speechRecognizer.RecognizeAsync();
if (Operation.Status == SpeechRecognitionResultStatus.Success)
{
ResultGenerated(Operation.Text);
speechRecognizer.RecognizeAsync().Cancel();
speechRecognizer.Dispose();
speechRecognizer = null;
}
}
catch (Exception)
{
}
}
private async void Setup(Language language)
{
if (_recogniser != null)
{
_recogniser.ContinuousRecognitionSession.Completed -= Recogniser_Completed;
_recogniser.ContinuousRecognitionSession.ResultGenerated -= Recogniser_ResultGenerated;
_recogniser.HypothesisGenerated -= SpeechRecognizer_HypothesisGenerated;
_recogniser.Dispose();
_recogniser = null;
}
_recogniser = new SpeechRecognizer(language);
SpeechRecognitionTopicConstraint constraint = new SpeechRecognitionTopicConstraint(
SpeechRecognitionScenario.Dictation, "dictation");
_recogniser.Constraints.Add(constraint);
SpeechRecognitionCompilationResult result = await _recogniser.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
await ShowDialogAsync($"Grammar Compilation Failed: {result.Status.ToString()}");
}
_recogniser.ContinuousRecognitionSession.Completed += Recogniser_Completed;
_recogniser.ContinuousRecognitionSession.ResultGenerated += Recogniser_ResultGenerated;
_recogniser.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
}
public static async void RecognizeSpeech()
{
SpeechRecognizer recognizer = new SpeechRecognizer();
recognizer.Timeouts.BabbleTimeout = System.TimeSpan.FromSeconds(120.0);
recognizer.Timeouts.EndSilenceTimeout = System.TimeSpan.FromSeconds(120.0);
recognizer.Timeouts.InitialSilenceTimeout = System.TimeSpan.FromSeconds(120.0);
SpeechRecognitionTopicConstraint topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Message");
recognizer.Constraints.Add(topicConstraint);
await recognizer.CompileConstraintsAsync();
try {
SpeechRecognitionResult result = await recognizer.RecognizeAsync();
//use result.GetAlternates for more precisivion
if (result.Confidence != SpeechRecognitionConfidence.Rejected)
{
if (result.Text != "")
{
string speechResult = result.Text.Remove(result.Text.Length - 1);
int num;
bool isNumber = Int32.TryParse(speechResult, out num);
if (isNumber)
{
MainPage.SetAudioTempCommand(speechResult);
}
else
{
UiUtils.ShowNotification("Your message could not be parsed as number. Please specify a number!");
}
}
else
{
UiUtils.ShowNotification("Your message could not be parsed. Please repeat!");
}
}
else
{
UiUtils.ShowNotification("Sorry, could not get that. Can you repeat?");
}
}catch (Exception ex)
{
const int privacyPolicyHResult = unchecked ((int)0x80045509);
const int networkNotAvailable = unchecked ((int)0x80045504);
if (ex.HResult == privacyPolicyHResult)
{
UiUtils.ShowNotification("You will need to accept the speech privacy policy in order to use speech recognition in this app. Consider activating `Get to know me` in 'Settings->Privacy->Speech, inking & typing`");
}
else if (ex.HResult == networkNotAvailable)
{
UiUtils.ShowNotification("The network connection is not available");
}
else
{
var t = ex.Message;
}
}
}
/// <summary>
/// When activating the scenario, ensure we have permission from the user to access their microphone, and
/// provide an appropriate path for the user to enable access to the microphone if they haven't
/// given explicit permission for it.
/// </summary>
/// <param name="e">The navigation event details</param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
// enable the recognition buttons
btnRecognizeWithUI.IsEnabled = true;
btnRecognizeWithoutUI.IsEnabled = true;
}
else
{
this.resultTextBlock.Visibility = Visibility.Visible;
this.resultTextBlock.Text = "Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.";
}
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer();
// Provide feedback to the user about the state of the recognizer.
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Add a web search grammar to the recognizer.
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
speechRecognizer.Constraints.Add(webSearchGrammar);
// Compile the constraint.
await speechRecognizer.CompileConstraintsAsync();
}
private async void StartVoiceRecognition()
{
await SpeakText( "Say Captains Log at any time to create a log entry." );
speechRecognizerCaptainsLogCommand = new SpeechRecognizer();
while ( !cancellationSource.IsCancellationRequested )
{
// Listen for user to say "Captains Log"
ISpeechRecognitionConstraint commandConstraint =
new SpeechRecognitionListConstraint( new[] { "Captains Log", "Computer Captains Log" } );
speechRecognizerCaptainsLogCommand.Constraints.Add( commandConstraint );
await speechRecognizerCaptainsLogCommand.CompileConstraintsAsync();
SpeechRecognitionResult commandResult = await speechRecognizerCaptainsLogCommand.RecognizeAsync();
if ( commandResult.Status != SpeechRecognitionResultStatus.Success
|| commandResult.Confidence == SpeechRecognitionConfidence.Rejected
|| cancellationSource.IsCancellationRequested )
{
continue;
}
// Recognized user saying "Captains Log"
// Listen for the user's dictation entry
var captainsLogDictationRecognizer = new SpeechRecognizer();
ISpeechRecognitionConstraint dictationConstraint =
new SpeechRecognitionTopicConstraint(
SpeechRecognitionScenario.Dictation, "LogEntry", "LogEntryDictation" );
captainsLogDictationRecognizer.Constraints.Add( dictationConstraint );
await captainsLogDictationRecognizer.CompileConstraintsAsync();
captainsLogDictationRecognizer.UIOptions.ExampleText = "Boldly going where no man or woman has gone before.";
captainsLogDictationRecognizer.UIOptions.AudiblePrompt = "Go ahead";
captainsLogDictationRecognizer.UIOptions.IsReadBackEnabled = true;
captainsLogDictationRecognizer.UIOptions.ShowConfirmation = true;
SpeechRecognitionResult dictationResult = await captainsLogDictationRecognizer.RecognizeWithUIAsync();
if ( dictationResult.Status != SpeechRecognitionResultStatus.Success
|| dictationResult.Confidence == SpeechRecognitionConfidence.Rejected
|| string.IsNullOrWhiteSpace( dictationResult.Text )
|| cancellationSource.IsCancellationRequested )
{
captainsLogDictationRecognizer.Dispose();
continue;
}
// Recognized user's dictation entry
AddLogEntry( dictationResult.Text );
captainsLogDictationRecognizer.Dispose();
}
speechRecognizerCaptainsLogCommand.Dispose();
}
public async Task <bool> InitializeRecognizerAsync()
{
Debug.WriteLine("[Speech to Text]: initializing Speech Recognizer...");
if (_recognizer != null)
{
return(true);
}
_recognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
// Set UI text
_recognizer.UIOptions.AudiblePrompt = "What you want to do...";
// This requires internet connection
SpeechRecognitionTopicConstraint topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
_recognizer.Constraints.Add(topicConstraint);
SpeechRecognitionCompilationResult result = await _recognizer.CompileConstraintsAsync(); // Required
if (result.Status != SpeechRecognitionResultStatus.Success)
{
Debug.WriteLine("[Speech to Text]: Grammar Compilation Failed: " + result.Status.ToString());
return(false);
}
_recognizer.ContinuousRecognitionSession.ResultGenerated += (s, e) => { Debug.WriteLine($"[Speech to Text]: recognizer results: {e.Result.Text}, {e.Result.RawConfidence.ToString()}, {e.Result.Confidence.ToString()}"); };
Debug.WriteLine("[Speech to Text]: done initializing Speech Recognizer");
return(true);
}
/// <summary>
/// Initialize Speech Recognizer and compile constraints.
/// </summary>
/// <param name="recognizerLanguage">Language to use for the speech recognizer</param>
/// <returns>Awaitable task.</returns>
private async Task InitializeRecognizer(Language recognizerLanguage)
{
MicrophoneAccessStatus status = await AudioCapturePermissions.RequestMicrophoneAccessAsync();
if (status != MicrophoneAccessStatus.Allowed)
{
string prompt = status == MicrophoneAccessStatus.NoCaptureDevices ?
"没有检测到音频捕获设备，请检查设备后重试" :
"您没有允许本应用访问麦克风，请在 设置 -> 隐私 -> 麦克风 中设置";
var messageDialog = new MessageDialog(prompt);
await messageDialog.ShowAsync();
throw new Exception($"Request microphone access failed. Status: {status}");
}
Dispose();
// Create an instance of SpeechRecognizer.
_speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// Add a web search topic constraint to the recognizer.
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
_speechRecognizer.Constraints.Add(webSearchGrammar);
// RecognizeWithUIAsync allows developers to customize the prompts.
_speechRecognizer.UIOptions.AudiblePrompt = "请说出您想搜索的东西";
_speechRecognizer.UIOptions.ExampleText = "例如：“你好，美女”";
// Compile the constraint.
SpeechRecognitionCompilationResult compilationResult = await _speechRecognizer.CompileConstraintsAsync();
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile it.
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
throw new Exception($"Unable to compile grammar. Status: {compilationResult.Status}");
}
public async Task InitializeSpeechRecognizerAsync()
{
if (this.speechRecognizer != null)
{
this.DisposeSpeechRecognizer();
}
this.dictatedTextBuilder = new StringBuilder();
this.speechRecognizer = new SpeechRecognizer();
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
await new MessageDialog("CompileConstraintsAsync returned " + result.Status, "Error initializing SpeechRecognizer").ShowAsync();
return;
}
this.speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;;
this.speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
this.speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
}
/// <summary>
/// Tries to iniziaizlize the SpeechRecognizer object
/// </summary>
/// <returns>true if SpeechRecognizer is succesfully inizialized, false otherwise</returns>
private async Task <bool> TryInitSpeech()
{
bool retVal = false;
try
{
await TryDisposeSpeech();
speechRecognizer = new SpeechRecognizer();
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, DICTATION);
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
retVal = true;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
Text = SPEECH_RECOGNITION_FAILED;
retVal = false;
}
return(retVal);
}
public MainPage()
{
this.InitializeComponent();
var recognizer = new SpeechRecognizer();
var topicconstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "Development");
recognizer.Constraints.Add(topicconstraint);
var result =
recognizer.CompileConstraintsAsync();
}
public async Task Initialize()
{
if (!this.permissionGained)
{
await WindowManagerService.Current.MainDispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => this.permissionGained = await AudioCapturePermissions.RequestMicrophonePermission());
}
try
{
if (this.speechRecognizer != null)
{
this.speechRecognizer.StateChanged -= this.SpeechRecognizer_StateChanged;
this.speechRecognizer.ContinuousRecognitionSession.Completed -= this.ContinuousRecognitionSession_Completed;
this.speechRecognizer.ContinuousRecognitionSession.ResultGenerated -= this.ContinuousRecognitionSession_ResultGenerated;
this.speechRecognizer.HypothesisGenerated -= this.SpeechRecognizer_HypothesisGenerated;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
var recognizerLanguage = new Language(App.Settings.SpeechLocale); // SpeechRecognizer.SystemSpeechLanguage
this.speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// Provide feedback to the user about the state of the recognizer. This can be used to provide visual feedback in the form
// of an audio indicator to help the user understand whether they're being heard.
this.speechRecognizer.StateChanged += this.SpeechRecognizer_StateChanged;
// Apply the dictation topic constraint to optimize for dictated free-form speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
this.speechRecognizer.Constraints.Add(dictationConstraint);
var result = await this.speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
await this.dialogService.ShowError(result.Status.ToString(), "Grammar Compilation Failed", "OK", null);
}
// Handle continuous recognition events. Completed fires when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or the garbage rule is hit. HypothesisGenerated fires during recognition, and
// allows us to provide incremental feedback based on what the user's currently saying.
this.speechRecognizer.ContinuousRecognitionSession.Completed += this.ContinuousRecognitionSession_Completed;
this.speechRecognizer.ContinuousRecognitionSession.ResultGenerated += this.ContinuousRecognitionSession_ResultGenerated;
this.speechRecognizer.HypothesisGenerated += this.SpeechRecognizer_HypothesisGenerated;
await this.StartRecognizing(true);
}
catch (Exception ex)
{
if ((uint)ex.HResult == HResultRecognizerNotFound)
{
throw new Exception("Speech Language pack for selected language not installed.", ex);
}
else
{
throw;
}
}
}
public MainPage()
{
this.InitializeComponent();
var recognizer = new SpeechRecognizer();
var topicconstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "Development");
recognizer.Constraints.Add(topicconstraint);
var result =
recognizer.CompileConstraintsAsync();
}
/// <summary>
/// When activating the scenario, ensure we have permission from the user to access their microphone, and
/// provide an appropriate path for the user to enable access to the microphone if they haven't
/// given explicit permission for it.
/// </summary>
/// <param name="e">The navigation event details</param>
private async Task InitSpeech()
{
// Save the UI thread dispatcher to allow speech status messages to be shown on the UI.
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
// Enable the recognition buttons.
button.IsEnabled = true;
if (speechRecognizer != null)
{
// cleanup prior to re-initializing this scenario.
//speechRecognizer.StateChanged -= SpeechRecognizer_StateChanged;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer();
// Provide feedback to the user about the state of the recognizer.
//speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Compile the dictation topic constraint, which optimizes for dictated speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile it.
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
// Disable the recognition buttons.
button.IsEnabled = false;
// Let the user know that the grammar didn't compile properly.
//resultTextBlock.Visibility = Visibility.Visible;
//resultTextBlock.Text = "Unable to compile grammar.";
}
}
else
{
// "Permission to access capture resources was not given by the user; please set the application setting in Settings->Privacy->Microphone.";
button.IsEnabled = false;
}
await Task.Yield();
}
public async Task <bool> InitializeRecognizerAsync()
{
Debug.WriteLine("[Speech to Text]: initializing Speech Recognizer...");
var language = new Windows.Globalization.Language(_languageName);
_recognizer = new SpeechRecognizer(language);
// Set timeout settings.
_recognizer.Timeouts.InitialSilenceTimeout = TimeSpan.FromSeconds(_recognizerInitialSilenceTimeOutInSeconds);
_recognizer.Timeouts.BabbleTimeout = TimeSpan.FromSeconds(_recognizerBabbleTimeoutInSeconds);
_recognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(_recognizerEndSilenceTimeoutInSeconds);
// Set UI text
_recognizer.UIOptions.AudiblePrompt = "Say what you want to do...";
if (!this.IsOffline())
{
// This requires internet connection
SpeechRecognitionTopicConstraint topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
_recognizer.Constraints.Add(topicConstraint);
}
else
{
// In case of network issue
string[] responses =
{
"I would like to rent a bike",
"I want to rent a bike",
"I'd like to rent a bike",
"rent a bike",
"I would like to rent a bicycle",
"I want to rent a bicycle",
"I'd like to rent a bicycle",
"rent a bicycle"
};
// Add a list constraint to the recognizer.
var listConstraint = new SpeechRecognitionListConstraint(responses, "rentBikePhrases");
_recognizer.Constraints.Add(listConstraint);
}
SpeechRecognitionCompilationResult result = await _recognizer.CompileConstraintsAsync(); // Required
if (result.Status != SpeechRecognitionResultStatus.Success)
{
Debug.WriteLine("[Speech to Text]: Grammar Compilation Failed: " + result.Status.ToString());
return(false);
}
_recognizer.HypothesisGenerated += Recognizer_HypothesisGenerated;
_recognizer.StateChanged += Recognizer_StateChanged;
_recognizer.ContinuousRecognitionSession.ResultGenerated += (s, e) => { Debug.WriteLine($"[Speech to Text]: recognizer results: {e.Result.Text}, {e.Result.RawConfidence.ToString()}, {e.Result.Confidence.ToString()}"); };
Debug.WriteLine("[Speech to Text]: done initializing Speech Recognizer");
return(true);
}
/// <summary>
/// Initializes a SpeechRecognition object, configuring the recognizer and grammar.
/// </summary>
/// <returns>True if the initialization process succeeded.</returns>
public async Task <bool> Initialize()
{
speechRecognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
speechRecognizer.Constraints.Add(webSearchGrammar);
var compilationResult = await speechRecognizer.CompileConstraintsAsync();
return(compilationResult.Status == SpeechRecognitionResultStatus.Success);
}
public async Task InitializeSpeechRecognizerAsync()
{
speechRecognizerUI = new SpeechRecognizer();
speechRecognizerUI.UIOptions.IsReadBackEnabled = true;
speechRecognizerUI.UIOptions.ShowConfirmation = true;
SpeechRecognitionTopicConstraint topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Dear Diary");
speechRecognizerUI.Constraints.Add(topicConstraint);
await speechRecognizerUI.CompileConstraintsAsync();
}
/// <summary>
/// When activating the scenario, ensure we have permission from the user to access their microphone, and
/// provide an appropriate path for the user to enable access to the microphone if they haven't
/// given explicit permission for it.
/// </summary>
/// <param name="e">The navigation event details</param>
private async Task InitSpeech()
{
// Save the UI thread dispatcher to allow speech status messages to be shown on the UI.
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
// Enable the recognition buttons.
button.IsEnabled = true;
if (speechRecognizer != null)
{
// cleanup prior to re-initializing this scenario.
//speechRecognizer.StateChanged -= SpeechRecognizer_StateChanged;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer();
// Provide feedback to the user about the state of the recognizer.
//speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Compile the dictation topic constraint, which optimizes for dictated speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile it.
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
// Disable the recognition buttons.
button.IsEnabled = false;
// Let the user know that the grammar didn't compile properly.
//resultTextBlock.Visibility = Visibility.Visible;
//resultTextBlock.Text = "Unable to compile grammar.";
}
}
else
{
// "Permission to access capture resources was not given by the user; please set the application setting in Settings->Privacy->Microphone.";
button.IsEnabled = false;
}
await Task.Yield();
}
async private void OnRecognizeNoUI(object sender, RoutedEventArgs e)
{
var recognizer = new SpeechRecognizer();
var topic = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
recognizer.Constraints.Add(topic);
await recognizer.CompileConstraintsAsync();
var result = await recognizer.RecognizeAsync();
txt_dictation.Text = result.Text;
}
private async void VoiceButton_Tapped(object sender, TappedRoutedEventArgs e)
{
var speechRecognizer = new SpeechRecognizer();
var topicConstraing = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
speechRecognizer.Constraints.Add(topicConstraing);
await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
private async void InitializeRecognizer()
{
var grammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "SmartSounder");
_recognizer.Constraints.Add(grammar);
var result = await _recognizer.CompileConstraintsAsync();
_recognizer.ContinuousRecognitionSession.AutoStopSilenceTimeout = new TimeSpan(0, 0, 2);
if (result.Status != SpeechRecognitionResultStatus.Success)
{
throw new Exception();
}
}
public async void RecognizeSpeech()
{
var speechRecognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
var srcpres = await speechRecognizer.CompileConstraintsAsync();
if (srcpres.Status != SpeechRecognitionResultStatus.Success)
{
Console.WriteLine("Failed to compile constraints");
exitEvent.Set();
return;
}
while (true)
{
var res = await speechRecognizer.RecognizeAsync();
switch (res.Status)
{
case SpeechRecognitionResultStatus.Success:
break;
default:
Console.WriteLine($"Failed ({res.Status.ToString()}), try again");
continue;
}
switch (res.Confidence)
{
case SpeechRecognitionConfidence.Low:
case SpeechRecognitionConfidence.Rejected:
Console.WriteLine("Not enough confidence...");
continue;
}
UiBuiltins.Notification(
header: "Text spoken",
message: res.Text
);
if (res.Text == ExitKeyword)
{
exitEvent.Set();
break;
}
}
}
/// <summary>
/// Runs the service.
/// </summary>
/// <param name="state">The state<see cref="object"/></param>
private static async void Run(object state)
{
try
{
// restart listener if nothing has happend for more than 30 seconds
if (lastListenCylce > DateTime.Now.AddSeconds(-30))
{
return;
}
if (recognizer != null)
{
try
{
await recognizer.StopRecognitionAsync();
}
catch (Exception ex)
{
Log(ex);
}
}
recognizer = new SpeechRecognizer(new Language("de-DE"));
recognizer.Timeouts.InitialSilenceTimeout = TimeSpan.FromSeconds(2);
recognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(0.5);
recognizer.StateChanged += RecognizerStateChanged;
recognizer.ContinuousRecognitionSession.ResultGenerated += RecognizerResultGenerated;
var textGrammar = new SpeechRecognitionListConstraint(new List <string> {
"Licht an", "Licht aus"
});
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
recognizer.Constraints.Add(textGrammar);
recognizer.Constraints.Add(webSearchGrammar);
SpeechRecognitionCompilationResult compilationResult = await recognizer.CompileConstraintsAsync();
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
Log(LogLevel.Debug, "Speechrecognition compile result: " + compilationResult.ToString());
await Listen();
}
else
{
Log(LogLevel.Debug, "Speechrecognition compile result: " + compilationResult.ToString());
}
}
catch (Exception ex)
{
Log(ex);
}
}
/// <summary>
/// Initialize Speech Recognizer and compile constraints.
/// </summary>
/// <param name="recognizerLanguage">Language to use for the speech recognizer</param>
/// <returns>Awaitable task.</returns>
private async Task InitializeRecognizer(Language recognizerLanguage)
{
if (speechRecognizer != null)
{
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
try
{
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// Compile the dictation topic constraint, which optimizes for dictated speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
throw;
}
try
{
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
//// RecognizeWithUIAsync allows developers to customize the prompts.
//speechRecognizer.UIOptions.AudiblePrompt = "Dictate a phrase or sentence...";
//speechRecognizer.UIOptions.ExampleText = speechResourceMap.GetValue("DictationUIOptionsExampleText", speechContext).ValueAsString;
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile it.
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
//// Disable the recognition buttons.
//btnRecognizeWithUI.IsEnabled = false;
//btnRecognizeWithoutUI.IsEnabled = false;
//// Let the user know that the grammar didn't compile properly.
//resultTextBlock.Visibility = Visibility.Visible;
//resultTextBlock.Text = "Unable to compile grammar.";
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
throw;
}
}
/*
* Starts continuous recognition sessions for prolonged audio input from the user
*/
public static void InitContinuousSpeechRecognition()
{
m_recognizer = new SpeechRecognizer();
m_recognizer.Timeouts.BabbleTimeout = System.TimeSpan.FromSeconds(120.0);
m_recognizer.Timeouts.EndSilenceTimeout = System.TimeSpan.FromSeconds(120.0);
m_recognizer.Timeouts.InitialSilenceTimeout = System.TimeSpan.FromSeconds(120.0);
Debug.WriteLine("print1");
SpeechRecognitionTopicConstraint topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
m_recognizer.Constraints.Add(topicConstraint);
IAsyncOperation <SpeechRecognitionCompilationResult> asyncResult = m_recognizer.CompileConstraintsAsync();
asyncResult.Completed += CompileConstraintsCompletedHandler;
Debug.WriteLine("print2");
}
private async void btnSearch_Click(object sender, RoutedEventArgs e)
{
this.txtCortanaMessages.Text = "Je vous écoute...";
Windows.Globalization.Language langFR = new Windows.Globalization.Language("fr-FR");
SpeechRecognizer recognizer = new SpeechRecognizer(langFR);
SpeechRecognitionTopicConstraint topicConstraint
= new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
recognizer.Constraints.Add(topicConstraint);
await recognizer.CompileConstraintsAsync(); // Required
var recognition = recognizer.RecognizeAsync();
recognition.Completed += this.Recognition_Completed;
}
public MainPage()
{
InitializeComponent();
NavigationCacheMode = NavigationCacheMode.Required;
_speechRecognizer = new SpeechRecognizer();
_speechRecognizer.StateChanged += SpeechRecognizerOnStateChanged;
_speechRecognizer.RecognitionQualityDegrading += SpeechRecognizerOnRecognitionQualityDegrading;
// Create an instance of SpeechRecognizer.
var topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
_speechRecognizer.Constraints.Add(topicConstraint);
// Compile the dictation grammar by default.
_speechRecognizer.CompileConstraintsAsync();
}
async private void OnRecognizeFromWeb(object sender, RoutedEventArgs e)
{
var recognizer = new SpeechRecognizer();
recognizer.UIOptions.ExampleText = "You can say 'Something'";
recognizer.UIOptions.AudiblePrompt = "Say something I'm giving up on you.";
recognizer.UIOptions.IsReadBackEnabled = false;
recognizer.UIOptions.ShowConfirmation = false;
var topic = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
recognizer.Constraints.Add(topic);
await recognizer.CompileConstraintsAsync();
var result = await recognizer.RecognizeWithUIAsync();
txt_dictation.Text = result.Text;
}
private async void Init(Windows.Globalization.Language language)
{
ListenButton.IsEnabled = false;
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (!permissionGained)
{
MessageDialog("Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.");
}
var recognizer = new SpeechRecognizer(language);
var topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
recognizer.Constraints.Add(topicConstraint);
var compilationResult = await recognizer.CompileConstraintsAsync();
_SpeechRecognizer = recognizer;
ListenButton.IsEnabled = true;
}
public async Task LoadRecognizerAsync()
{
var permission = await Template10.Utils.AudioUtils.RequestMicrophonePermission();
if (permission && _SpeechRecognizer == null)
{
_SpeechRecognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
var constraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
_SpeechRecognizer.Constraints.Add(constraint);
var compilation = await _SpeechRecognizer.CompileConstraintsAsync();
if (compilation.Status != SpeechRecognitionResultStatus.Success)
throw new Exception(compilation.Status.ToString());
}
else if (!permission)
{
throw new Exception("RequestMicrophonePermission returned false");
}
}
/// <summary>
/// Upon entering the scenario, ensure that we have permissions to use the Microphone. This may entail popping up
/// a dialog to the user on Desktop systems. Only enable functionality once we've gained that permission in order to
/// prevent errors from occurring when using the SpeechRecognizer. If speech is not a primary input mechanism, developers
/// should consider disabling appropriate parts of the UI if the user does not have a recording device, or does not allow
/// audio input.
/// </summary>
/// <param name="e">Unused navigation parameters</param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
rootPage = MainPage.Current;
// Keep track of the UI thread dispatcher, as speech events will come in on a separate thread.
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// Prompt the user for permission to access the microphone. This request will only happen
// once, it will not re-prompt if the user rejects the permission.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
btnContinuousRecognize.IsEnabled = true;
}
else
{
this.dictationTextBox.Text = "Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.";
}
this.speechRecognizer = new SpeechRecognizer();
// Provide feedback to the user about the state of the recognizer. This can be used to provide visual feedback in the form
// of an audio indicator to help the user understand whether they're being heard.
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
rootPage.NotifyUser("Grammar Compilation Failed: " + result.Status.ToString(), NotifyType.ErrorMessage);
btnContinuousRecognize.IsEnabled = false;
}
// Handle continuous recognition events. Completed fires when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or the garbage rule is hit. HypothesisGenerated fires during recognition, and
// allows us to provide incremental feedback based on what the user's currently saying.
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
}
private static async void InitializeSpeechRecognizer(Language language)
{
speechRecognizer = new SpeechRecognizer(language);
var grammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Dictation");
speechRecognizer.Constraints.Add(grammar);
await speechRecognizer.CompileConstraintsAsync();
SpeechRecognitionCompilationResult result =
await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.ResultGenerated +=
ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.ContinuousRecognitionSession.Completed +=
ContinuousRecognitionSession_Completed;
speechRecognizer.HypothesisGenerated +=
SpeechRecognizer_HypothesisGenerated;
}
private async Task CompileDictationConstraint()
{
#if VERBOSE_DEBUG
Debug.WriteLine("SpeechManager: Compiling dictation constraint");
#endif
SpeechRecognizer.Constraints.Clear();
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
SpeechRecognizer.Constraints.Add(dictationConstraint);
var result = await SpeechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
Debug.WriteLine("SpeechRecognizer.CompileConstraintsAsync failed for dictation");
}
}
private async void Init(Windows.Globalization.Language language)
{
ListenButton.IsEnabled = false;
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (!permissionGained)
{
MessageDialog("Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.");
}
var recognizer = new SpeechRecognizer(language);
var topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
recognizer.Constraints.Add(topicConstraint);
var compilationResult = await recognizer.CompileConstraintsAsync();
_SpeechRecognizer = recognizer;
ListenButton.IsEnabled = true;
}
/// <summary>
/// Initialize Speech Recognizer and compile constraints.
/// </summary>
/// <param name="recognizerLanguage">Language to use for the speech recognizer</param>
/// <returns>Awaitable task.</returns>
private async Task InitializeRecognizer()
{
// await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
// dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
if (speechRecognizer != null)
{
// cleanup prior to re-initializing this scenario.
speechRecognizer.StateChanged -= SpeechRecognizer_StateChanged;
speechRecognizer.ContinuousRecognitionSession.Completed -= ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated -= ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated -= SpeechRecognizer_HypothesisGenerated;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
this.speechRecognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
// Provide feedback to the user about the state of the recognizer. This can be used to provide visual feedback in the form
// of an audio indicator to help the user understand whether they're being heard.
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
Debug.WriteLine("Grammar Compilation Failed: " + result.Status.ToString());
// rootPage.NotifyUser("Grammar Compilation Failed: " + result.Status.ToString(), NotifyType.ErrorMessage);
//btnContinuousRecognize.IsEnabled = false;
}
// Handle continuous recognition events. Completed fires when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or the garbage rule is hit. HypothesisGenerated fires during recognition, and
// allows us to provide incremental feedback based on what the user's currently saying.
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
}
//------------------------------------------------------------------------------------------------------------------------
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
//use the connection string aquired from the Device Explorer
deviceClient = DeviceClient.CreateFromConnectionString("HostName=demoyodiwohub......", TransportType.Http1);
#if GROVE_ENABLED
rotarywatcher = new RotaryWatcher(GrovePi.Pin.AnalogPin2);
rotarywatcher.OnNewValueAcquiredCb = OnSensedValue;
rotarywatcher.Watch();
buttonwatcher = new ButtonWatcher(GrovePi.Pin.DigitalPin3);
buttonwatcher.OnNewValueAcquiredCb = OnSensedValue;
//buttonwatcher.Watch();
lightwatcher = new LightWatcher(GrovePi.Pin.DigitalPin4);
lightwatcher.OnNewValueAcquiredCb = OnSensedValue;
//lightwatcher.Watch();
led = new Led(GrovePi.Pin.DigitalPin5);
lcd = new LCD();
#endif
//start speech recognition
try
{
speechRecognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
var result = await speechRecognizer.CompileConstraintsAsync();
if (result.Status == SpeechRecognitionResultStatus.Success)
{
//start recogniser
try { recognHeartBeat(); } catch { }
}
}
catch { }
//receive events from the Azure IOT hub
ReceiveDataFromAzure();
}
private async void VoiceButton_Click(object sender, RoutedEventArgs e)
{
try
{
// Get the top user-preferred language and its display name.
var topUserLanguage = Windows.System.UserProfile.GlobalizationPreferences.Languages[0];
var language = new Windows.Globalization.Language(topUserLanguage);
firstStopAttemptDone = false;
listening = true;
using (speechRecognizer = new SpeechRecognizer(language))
{
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, WEB_SEARCH);
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
// setting timeouts
speechRecognizer.Timeouts.InitialSilenceTimeout = TimeSpan.FromSeconds(4.0);
speechRecognizer.Timeouts.BabbleTimeout = TimeSpan.FromSeconds(4.0);
speechRecognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(1.0);
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
return;
VisualStateManager.GoToState(this, VISUAL_STATE_LISTENING, true);
this.IsReadOnly = true;
this.Text = LISTENING_TEXT;
SpeechRecognitionResult speechRecognitionResult = await speechRecognizer.RecognizeAsync();
if (speechRecognitionResult.Status == SpeechRecognitionResultStatus.Success)
Text = speechRecognitionResult.Text;
else
Text = SPEECH_RECOGNITION_FAILED;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
Text = string.Empty;
}
finally
{
timer.Stop();
hypotesis = string.Empty;
VisualStateManager.GoToState(this, VISUAL_STATE_NOT_LISTENING, true);
this.IsReadOnly = false;
listening = false;
}
}
private async Task InitializeRecognizer(Language recognizerLanguage)
{
if (speechRecognizer != null)
{
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
speechRecognizer = new SpeechRecognizer(recognizerLanguage);
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
Status.Text = "エラー";
}
}
private async void VoiceRecognizer()
{
voiceRecognizer = new SpeechRecognizer();
SpeechRecognitionTopicConstraint topicContraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "development");
voiceRecognizer.Constraints.Add(topicContraint);
SpeechRecognitionCompilationResult result = await voiceRecognizer.CompileConstraintsAsync();
SpeechRecognitionResult speechRecognitionResult = await voiceRecognizer.RecognizeAsync();
//voiceRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
//voiceRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
//await voiceRecognizer.ContinuousRecognitionSession.StartAsync();
if (pname == "Lorenzo")
{
if (speechRecognitionResult.Text.Contains("expensive") || speechRecognitionResult.Text.Contains("expense"))
{
//speechText.Text = "So much expensive";
ReadVoice(Error.Not_Found);
//pageView.Navigate(new Uri("http://www.americanas.com.br/produto/113151382/carro-eletrico-sport-car-vermelho-6v"));
}
else
{
ReadVoice(Error.Not_Found);
}
}
else
{
ReadVoice(Error.Not_Found);
}
}
private async Task InitSpeech()
{
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
bool permissionGained = await Template10.Utils.AudioUtils.RequestMicrophonePermission();
if (permissionGained)
{
button.IsEnabled = true;
if (speechRecognizer != null)
{
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
speechRecognizer = new SpeechRecognizer();
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
button.IsEnabled = false;
}
else
{
Text = string.Format("Permission to access mic denied by the user");
button.IsEnabled = false;
}
await Task.Yield();
}
private async void InitializeSpeechRecognizer()
{
try
{
if (speechRecognizer != null)
{
speechRecognizer.RecognizeAsync().Cancel();
speechRecognizer.RecognizeAsync().Close();
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
speechRecognizer = new SpeechRecognizer();
var topicConstraing = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
speechRecognizer.Constraints.Add(topicConstraing);
await speechRecognizer.CompileConstraintsAsync();
this.Operation = await speechRecognizer.RecognizeAsync();
if (Operation.Status == SpeechRecognitionResultStatus.Success)
{
ResultGenerated(Operation.Text);
speechRecognizer.RecognizeAsync().Cancel();
speechRecognizer.Dispose();
speechRecognizer = null;
}
}
catch (Exception)
{
}
}
/// <summary>
/// Initialize Speech Recognizer and compile constraints.
/// </summary>
/// <param name="recognizerLanguage">Language to use for the speech recognizer</param>
/// <returns>Awaitable task.</returns>
private async Task InitializeRecognizer(Language recognizerLanguage)
{
if (speechRecognizer != null)
{
// cleanup prior to re-initializing this scenario.
speechRecognizer.StateChanged -= SpeechRecognizer_StateChanged;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// Provide feedback to the user about the state of the recognizer.
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Add a web search topic constraint to the recognizer.
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
speechRecognizer.Constraints.Add(webSearchGrammar);
// RecognizeWithUIAsync allows developers to customize the prompts.
speechRecognizer.UIOptions.AudiblePrompt = "Say what you want to search for...";
speechRecognizer.UIOptions.ExampleText = speechResourceMap.GetValue("WebSearchUIOptionsExampleText", speechContext).ValueAsString;
// Compile the constraint.
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile it.
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
// Disable the recognition buttons.
btnRecognizeWithUI.IsEnabled = false;
btnRecognizeWithoutUI.IsEnabled = false;
// Let the user know that the grammar didn't compile properly.
resultTextBlock.Visibility = Visibility.Visible;
resultTextBlock.Text = "Unable to compile grammar.";
}
}
private async Task InitializeRecognizer(Language recognizerLanguage)
{
if (speechRecognizer != null)
{
speechRecognizer.ContinuousRecognitionSession.Completed -= ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated -= ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated -= SpeechRecognizer_HypothesisGenerated;
speechRecognizer.Dispose();
speechRecognizer = null;
}
speechRecognizer = new SpeechRecognizer(recognizerLanguage);
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
checkError.Visibility = Visibility.Visible;
errorCheck.Visibility = Visibility.Visible;
errorCheck.Text = "Recognition Failed!";
}
// Handle continuous recognition events. Completed fires when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or the garbage rule is hit. HypothesisGenerated fires during recognition, and
// allows us to provide incremental feedback based on what the user's currently saying.
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
}
// Initialize Speech Recognizer
private async void InitializeSpeechRecognizer()
{
// Initialize name recognizer
nameRecognizer = new SpeechRecognizer();
// Create list constraint
SpeechRecognitionListConstraint listConstraint = new SpeechRecognitionListConstraint(listOfNames);
// Add list constraint and compile
nameRecognizer.Constraints.Add(listConstraint);
SpeechRecognitionCompilationResult nameResult = await nameRecognizer.CompileConstraintsAsync();
if (nameResult.Status != SpeechRecognitionResultStatus.Success)
{
ListenerStatus.Text = "Unable to initialize Name listener.";
return;
}
// Initialize item recognizer
itemRecognizer = new SpeechRecognizer();
// Create topic constraint
SpeechRecognitionTopicConstraint topicConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "Short Form");
// Add topic constraint and compile
itemRecognizer.Constraints.Add(topicConstraint);
SpeechRecognitionCompilationResult itemresult = await itemRecognizer.CompileConstraintsAsync();
if (itemresult.Status != SpeechRecognitionResultStatus.Success)
{
ListenerStatus.Text = "Unable to initialize Item listener.";
return;
}
listeningIsEnabled = true;
ListenerStatus.Text = "Listeners initialized correctly.";
}
//protected async override void OnNavigatedTo(NavigationEventArgs e)
protected async Task GotoNavigation()
{
// Prompt the user for permission to access the microphone. This request will only happen
// once, it will not re-prompt if the user rejects the permission.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
//btnContinuousRecognize.IsEnabled = true;
}
else
{
this.dictationTextBox.Text = "Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.";
}
// var lang = new Windows.Globalization.Language("en-US");
// var lang = new Windows.Globalization.Language("en-US");zh-CN
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
//object outValue;
//CoreApplication.Properties.TryGetValue("speechRecognizer", out outValue);
//SpeechRecognizer t = (SpeechRecognizer)outValue;
// t.Constraints.Add(dictationConstraint);
speechRecognizer.Constraints.Add(dictationConstraint);
//SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
try
{
await speechRecognizer.CompileConstraintsAsync();
}
catch (Exception ex)
{
string mg = ex.Message;
}
//if (result.Status != SpeechRecognitionResultStatus.Success)
//{
// // btnContinuousRecognize.IsEnabled = false;
//}
//handle contiuous recognition events. Completed filres when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or hte garbate rule is hit. HypothesisGenerated fires during recognition, and
//allow us to rovide incremental feedback based on what the users' currently saying
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
await startDictate();
}
private async Task InitSpeech()
{
button.IsEnabled = true;
if (speechRecognizer != null)
{
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
speechRecognizer = new SpeechRecognizer();
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, DICTATION);
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
button.IsEnabled = false;
await Task.Yield();
}
/// <summary>
/// Tries to iniziaizlize the SpeechRecognizer object
/// </summary>
/// <returns>true if SpeechRecognizer is succesfully inizialized, false otherwise</returns>
private async Task<bool> TryInitSpeech()
{
bool retVal = false;
try
{
await TryDisposeSpeech();
speechRecognizer = new SpeechRecognizer();
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, DICTATION);
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
retVal = true;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
Text = SPEECH_RECOGNITION_FAILED;
retVal = false;
}
return retVal;
}
private async void InitializeSpeechRecognizer()
{
if (speechRecognizer != null)
{
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
speechRecognizer = new SpeechRecognizer();
var topicConstraing = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
speechRecognizer.Constraints.Add(topicConstraing);
await speechRecognizer.CompileConstraintsAsync();
var operation = await speechRecognizer.RecognizeAsync();
if (!this.Completed && operation.Status == SpeechRecognitionResultStatus.Success)
{
this.Completed = true;
ResultGenerated(operation.Text);
speechRecognizer.RecognizeAsync().Cancel();
speechRecognizer.Dispose();
speechRecognizer = null;
}
}
private async void btnSearch_Click(object sender, RoutedEventArgs e)
{
this.txtCortanaMessages.Text = "Je vous écoute...";
Windows.Globalization.Language langFR = new Windows.Globalization.Language("fr-FR");
SpeechRecognizer recognizer = new SpeechRecognizer(langFR);
SpeechRecognitionTopicConstraint topicConstraint
= new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
recognizer.Constraints.Add(topicConstraint);
await recognizer.CompileConstraintsAsync(); // Required
var recognition = recognizer.RecognizeAsync();
recognition.Completed += this.Recognition_Completed;
}
/// <summary>
/// Initialize Speech Recognizer and compile constraints.
/// </summary>
/// <param name="recognizerLanguage">Language to use for the speech recognizer</param>
/// <returns>Awaitable task.</returns>
private async Task InitializeRecognizer(Language recognizerLanguage)
{
if (speechRecognizer != null)
{
// cleanup prior to re-initializing this scenario.
speechRecognizer.StateChanged -= SpeechRecognizer_StateChanged;
speechRecognizer.ContinuousRecognitionSession.Completed -= ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated -= ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated -= SpeechRecognizer_HypothesisGenerated;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
this.speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// Provide feedback to the user about the state of the recognizer. This can be used to provide visual feedback in the form
// of an audio indicator to help the user understand whether they're being heard.
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
rootPage.NotifyUser("Grammar Compilation Failed: " + result.Status.ToString(), NotifyType.ErrorMessage);
btnContinuousRecognize.IsEnabled = false;
}
// Handle continuous recognition events. Completed fires when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or the garbage rule is hit. HypothesisGenerated fires during recognition, and
// allows us to provide incremental feedback based on what the user's currently saying.
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
}
private async void VoiceButton_Tapped(object sender, TappedRoutedEventArgs e)
{
var speechRecognizer = new SpeechRecognizer();
var topicConstraing = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Development");
speechRecognizer.Constraints.Add(topicConstraing);
await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
BackgroundTaskDeferral deferral = taskInstance.GetDeferral(); // This must be retrieved prior to subscribing to events below which use it
using (MopidyClient client = new MopidyClient())
{
await client.Open();
await client.Play("spotify:track:1hKdDCpiI9mqz1jVHRKG0E");
var speechRecognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
speechRecognizer.Constraints.Add(webSearchGrammar);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile it.
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
while (true)
{
var recognitionOperation = speechRecognizer.RecognizeAsync();
SpeechRecognitionResult speechRecognitionResult = await recognitionOperation;
if (speechRecognitionResult.Status == SpeechRecognitionResultStatus.Success)
{
if (speechRecognitionResult.Text.StartsWith("play", StringComparison.OrdinalIgnoreCase))
{
string playSearchString = speechRecognitionResult.Text.Substring(4).Trim();
string uri;
if (playSearchString.StartsWith("artist", StringComparison.OrdinalIgnoreCase))
{
uri = await client.SearchArtist(playSearchString.Substring(6).Trim());
}
else
{
uri = await client.Search(playSearchString);
}
if (uri != null)
{
await client.Play(uri);
}
}
else if (speechRecognitionResult.Text.StartsWith("stop", StringComparison.OrdinalIgnoreCase))
{
await client.Stop();
}
else if (speechRecognitionResult.Text.StartsWith("louder", StringComparison.OrdinalIgnoreCase))
{
int volume = await client.GetVolume();
volume = Math.Min(volume + 10, 100);
await client.SetVolume(volume);
}
else if (speechRecognitionResult.Text.StartsWith("quieter", StringComparison.OrdinalIgnoreCase))
{
int volume = await client.GetVolume();
volume = Math.Max(volume - 10, 0);
await client.SetVolume(volume);
}
else if (speechRecognitionResult.Text.StartsWith("mute", StringComparison.OrdinalIgnoreCase))
{
await client.SetVolume(0);
}
}
else
{
//resultTextBlock.Visibility = Visibility.Visible;
//resultTextBlock.Text = string.Format("Speech Recognition Failed, Status: {0}", speechRecognitionResult.Status.ToString());
}
}
}
}
}
