private async void InitRecognitionEngine()
{
try
{
speechRecognizer = new SpeechRecognizer(new Language(languageTag));
}
catch
{
speechRecognizer = new SpeechRecognizer();
}
speechRecognizer.Constraints.Add(new SpeechRecognitionListConstraint(GetCommandsText(), "tag1"));
//var op = speechRecognizer.CompileConstraintsAsync();
//op.AsTask().Wait();
////var a = op.GetResults();
//var op2 = speechRecognizer.RecognizeAsync();
//op2.AsTask().Wait();
//SpeechRecognitionResult result = op2.GetResults();
//if (result.Status == SpeechRecognitionResultStatus.Success)
//{
//}
var a = await speechRecognizer.CompileConstraintsAsync();
var b = a;
SpeechRecognitionResult result = await speechRecognizer.RecognizeAsync();
//if (result.Status == SpeechRecognitionResultStatus.Success)
// phoneNumber = result.Text;
// var cultureInfo = new CultureInfo("ru-RU");
// //var cultureInfo = new CultureInfo("en-US");
// Thread.CurrentThread.CurrentCulture = cultureInfo;
// Thread.CurrentThread.CurrentUICulture = cultureInfo;
// /*
// •en-GB. English (United Kingdom)
// •en-US. English (United States)
// •de-DE. German (Germany)
// •es-ES. Spanish (Spain)
// •fr-FR. French (France)
// •ja-JP. Japanese (Japan)
// •zh-CN. Chinese (China)
// •zh-TW. Chinese (Taiwan)
// */
// var commands = GetCommandsText();
// var choices = new Choices(commands);
// var builder = new GrammarBuilder(choices);
// builder.Culture = cultureInfo;
// recognitionEngine = new SpeechRecognitionEngine();// (cultureInfo);
// recognitionEngine.SetInputToDefaultAudioDevice();
// recognitionEngine.UnloadAllGrammars();
// recognitionEngine.LoadGrammar(new Grammar(builder));
// //recognitionEngine.LoadGrammar(new DictationGrammar()); // любой текст
// recognitionEngine.SpeechRecognized += recognitionEngine_SpeechRecognized;
// recognitionEngine.RecognizeAsync(RecognizeMode.Multiple);
}
public static async Task <SpeechRecognitionResult> ListenOnceAsync()
{
if (!IsStarted)
{
try
{
IsStarted = true;
recognizer = new SpeechRecognizer();
// compile the speech constraints and start listening
await recognizer.CompileConstraintsAsync();
// keep listening until the result isn't an empty string since sometimes it rings up false positives
SpeechRecognitionResult result = null;
while (result == null || StringUtils.IsBlank(result.Text))
{
result = await recognizer.RecognizeAsync();
}
return(result);
}
catch (Exception)
{
return(null);
}
}
else
{
throw new Exception("Can't Listen when already started!");
}
}
public async void StartOverlayRecognization()
{
OnstartEvent(new EventArgs());
// Create an instance of SpeechRecognizer.
speechRecognizer = InitSpeechRecognizer();
// Listen for audio input issues.
speechRecognizer.RecognitionQualityDegrading += speechRecognizer_RecognitionQualityDegrading;
// Add a web search grammar to the recognizer.
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
speechRecognizer.UIOptions.AudiblePrompt = "Say what you want to search for...";
speechRecognizer.UIOptions.ExampleText = @"Ex. 'weather for London'";
speechRecognizer.Constraints.Add(webSearchGrammar);
// Compile the constraint.
await speechRecognizer.CompileConstraintsAsync();
// Start recognition.
SpeechRecognitionResult speechRecognitionResult = await speechRecognizer.RecognizeWithUIAsync();
//await speechRecognizer.RecognizeWithUIAsync();
speechToTextEventArgs.SpeechResult = speechRecognitionResult.Text;
OnHaveResultEvent(speechToTextEventArgs);
//// Do something with the recognition result.
//var messageDialog = new Windows.UI.Popups.MessageDialog(speechRecognitionResult.Text, "Text spoken");
//await messageDialog.ShowAsync();
}
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> RegisterCortanaCommands(Dictionary <string, Action> commands)
{
try
{
cortanaCommands = commands;
SpeechRecognizer = new SpeechRecognizer();
var constraint = new SpeechRecognitionListConstraint(cortanaCommands.Keys);
SpeechRecognizer.Constraints.Clear();
SpeechRecognizer.Constraints.Add(constraint);
var result = await SpeechRecognizer.CompileConstraintsAsync();
if (result.Status == SpeechRecognitionResultStatus.Success)
{
SpeechRecognizer.ContinuousRecognitionSession.StartAsync();
SpeechRecognizer.ContinuousRecognitionSession.ResultGenerated += (s, e) =>
{
if (e.Result.RawConfidence >= 0.5f)
{
Action handler;
if (cortanaCommands.TryGetValue(e.Result.Text, out handler))
{
Application.InvokeOnMain(handler);
}
}
};
return(true);
}
return(false);
}
catch (Exception exc)
{
LogSharp.Warn("RegisterCortanaCommands: " + exc);
return(false);
}
}
private async Task CompilePhrases()
{
#if VERBOSE_DEBUG
Debug.WriteLine("SpeechManager: Compiling command phrase constraints");
#endif
try
{
SpeechRecognizer.Constraints.Clear();
AvailablePhrases.ForEach(p =>
{
string phraseNoSpaces = p.Replace(" ", String.Empty);
SpeechRecognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List <string>()
{
p
},
phraseNoSpaces));
});
var result = await SpeechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
Debug.WriteLine("SpeechManager: CompileConstraintsAsync failed for phrases");
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
/// <summary>
/// Code for voice recognition.
/// </summary>
//To initialize Speech Recognizer
public async void InitSpeechRecognizer(int n)
{
if (n == 0)
{
Rec.Dispose();
return;
}
Rec = new SpeechRecognizer();
Rec.ContinuousRecognitionSession.ResultGenerated += Rec_ResultGenerated;
StorageFile Store = await Package.Current.InstalledLocation.GetFileAsync(@"GrammarFile.xml");
SpeechRecognitionGrammarFileConstraint constraint = new SpeechRecognitionGrammarFileConstraint(Store);
Rec.Constraints.Add(constraint);
SpeechRecognitionCompilationResult result = await Rec.CompileConstraintsAsync();
if (result.Status == SpeechRecognitionResultStatus.Success)
{
status.Text = "Speech Recognition started.";
tts(status.Text);
Rec.UIOptions.AudiblePrompt = "Speech Recognition started.";
await Rec.ContinuousRecognitionSession.StartAsync();
}
}
public async Task InitializeRecognizer()
{
if (_speechRecognizer != null)
{
// cleanup prior to re-initializing this scenario.
DisposeSpeechRecognizer();
}
_speechRecognizer = new SpeechRecognizer(new Language("de-DE"));
_speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
//_speechRecognizer.Timeouts.InitialSilenceTimeout = TimeSpan.FromSeconds(10);
//_speechRecognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(10);
//_speechRecognizer.Timeouts.BabbleTimeout = TimeSpan.FromSeconds(10);
// Apply the dictation topic constraint to optimize for dictated freeform speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "maja");
_speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await _speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
ShowMessage("Grammar Compilation Failed: ");
}
}
private async void initializeSpeechRecognizer()
{
// Initialize recognizer
recognizer = new SpeechRecognizer();
// Set event handlers
recognizer.StateChanged += RecognizerStateChanged;
recognizer.ContinuousRecognitionSession.ResultGenerated += RecognizerResultGenerated;
// Load Grammer file constraint
string fileName = String.Format(SRGS_FILE);
StorageFile grammarContentFile = await Package.Current.InstalledLocation.GetFileAsync(fileName);
SpeechRecognitionGrammarFileConstraint grammarConstraint = new SpeechRecognitionGrammarFileConstraint(grammarContentFile);
// Add to grammer constraint
recognizer.Constraints.Add(grammarConstraint);
// Compile grammer
SpeechRecognitionCompilationResult compilationResult = await recognizer.CompileConstraintsAsync();
Debug.WriteLine("Status: " + compilationResult.Status.ToString());
// If successful, display the recognition result.
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
Debug.WriteLine("Result: " + compilationResult.ToString());
await recognizer.ContinuousRecognitionSession.StartAsync();
}
else
{
Debug.WriteLine("Status: " + compilationResult.Status);
}
}
public static async Task InitializeRecognizer(Language recognizerLanguage)
{
try
{
// determine the language code being used.
StorageFile grammarContentFile = await Package.Current.InstalledLocation.GetFileAsync(GrammarPath);
// Initialize the SpeechRecognizer and add the grammar.
speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// RecognizeWithUIAsync allows developers to customize the prompts.
SpeechRecognitionGrammarFileConstraint grammarConstraint = new SpeechRecognitionGrammarFileConstraint(grammarContentFile);
speechRecognizer.Constraints.Add(grammarConstraint);
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)
{
}
else
{
// Set EndSilenceTimeout to give users more time to complete speaking a phrase.
speechRecognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(SpeechTimespan);
}
}
catch (Exception ex)
{
var messageDialog = new Windows.UI.Popups.MessageDialog(ex.Message, "Exception");
await messageDialog.ShowAsync();
throw;
}
}
/// <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.
/// Construct a recognizer with a simple list of recognized terms.
/// </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;
// You could create any IEnumerable dynamically.
string[] responses = { "Yes", "No" };
// Add a list constraint to the recognizer.
var listConstraint = new SpeechRecognitionListConstraint(responses, "yesOrNo");
speechRecognizer.UIOptions.ExampleText = @"Ex. ""Yes"", ""No""";
speechRecognizer.Constraints.Add(listConstraint);
// Compile the constraint.
await speechRecognizer.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.
/// Construct a speech recognizer using the default dictation grammar.
/// </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.
this.speechRecognizer = new SpeechRecognizer();
// Provide feedback to the user about the state of the recognizer.
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Compile the dictation grammar that is loaded by default.
await speechRecognizer.CompileConstraintsAsync();
}
public async Task <string> RecordSpeechFromMicrophoneAsync()
{
string recognizedText = string.Empty;
using (SpeechRecognizer recognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage))
{
recognizer.Constraints.Add(new SpeechRecognitionListConstraint(acceptedUserInput));
await recognizer.CompileConstraintsAsync();
SpeechRecognitionResult result = await recognizer.RecognizeAsync();
StringBuilder stringBuilder = new StringBuilder();
if (result.Status == SpeechRecognitionResultStatus.Success)
{
if (result.Confidence == SpeechRecognitionConfidence.High)
{
stringBuilder.Append(result.Text);
}
else
{
IReadOnlyList <SpeechRecognitionResult> alternatives =
result.GetAlternates(1);
if (alternatives.First().RawConfidence > 0.5)
{
stringBuilder.Append(alternatives.First().Text);
}
}
recognizedText = stringBuilder.ToString();
}
}
return(recognizedText);
}
public async void StartRecognization()
{
OnstartEvent(new EventArgs());
// Create an instance of SpeechRecognizer.
speechRecognizer = InitSpeechRecognizer();
// Listen for audio input issues.
speechRecognizer.RecognitionQualityDegrading += speechRecognizer_RecognitionQualityDegrading;
// Add a web search grammar to the recognizer.
var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "webSearch");
speechRecognizer.UIOptions.AudiblePrompt = "Say what you want to search for...";
speechRecognizer.UIOptions.ExampleText = @"Ex. 'weather for London'";
speechRecognizer.Constraints.Add(webSearchGrammar);
// Compile the constraint.
await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
if (speechRecognizer.State == SpeechRecognizerState.Idle)
{
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
}
public override async Task InitializeAsync()
{
if (speechRecognizer == null)
{
try
{
var recognizer = new SpeechRecognizer(ConvertAILangToSystem(config.Language));
// INFO: Dictation is default Constraint
//var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
//recognizer.Constraints.Add(webSearchGrammar);
await recognizer.CompileConstraintsAsync();
lock (speechRecognizerLock)
{
if (speechRecognizer == null)
{
speechRecognizer = recognizer;
}
}
}
catch (Exception e)
{
if ((uint)e.HResult == HRESULT_LANG_NOT_SUPPORTED)
{
throw new AIServiceException(string.Format("Specified language {0} not supported or not installed on device", config.Language.code), e);
}
throw;
}
}
}
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)
{
btnContinuousRecognize.IsEnabled = false;
}
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
}
private async void StartSpeechRecognizer()
{
// Compile the loaded GrammarFiles
SpeechRecognitionCompilationResult compilationResult = await _recognizer.CompileConstraintsAsync();
// If successful, display the recognition result.
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
Debug.WriteLine("Result: " + compilationResult.ToString());
SpeechContinuousRecognitionSession session = _recognizer.ContinuousRecognitionSession;
try
{
await session.StartAsync();
}
catch (Exception e)
{
//TODO this needs to report to the user that something failed.
//also potentially write to a log somewhere.
Debug.WriteLine(e.Data);
}
}
else
{
//TODO this needs to report to the user that something failed.
//also potentially write to a log somewhere.
Debug.WriteLine("Status: " + compilationResult.Status);
}
}
/// <summary>
/// Starts a speech recognition session that can recognize the topics on the checklist and possibly related words, if that functionality is available
/// </summary>
/// Also adds the right callbacks to the speech recognizer
private async void startSpeechRecognition()
{
var constraint = new SpeechRecognitionListConstraint(app.getKeywords());
if (speechRecognizer?.State == SpeechRecognizerState.Capturing)
{
await speechRecognizer.ContinuousRecognitionSession.StopAsync();
}
speechRecognizer = new SpeechRecognizer();
speechRecognizer.Constraints.Add(constraint);
var speechCompilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += speechResultCallback;
if (speechRecognizer.State == SpeechRecognizerState.Idle)
{
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
Debug.WriteLine("Started speech recognition session");
}
else
{
Debug.WriteLine("Speech recognizer is not idle, attemptint to reboot");
await speechRecognizer.ContinuousRecognitionSession.StopAsync();
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
}
// start a speech recognition session and capture the results
private async void speechButton_Click(object sender, RoutedEventArgs e)
{
speechButton.Content = "Listening...";
speechButton.IsEnabled = false;
// Create an instance of SpeechRecognizer.
using (var speechRecognizer = new SpeechRecognizer())
{
// Compile the dictation grammar by default.
await speechRecognizer.CompileConstraintsAsync();
// Start recognition.
SpeechRecognitionResult speechRecognitionResult = await speechRecognizer.RecognizeAsync();
// output result
speechOutputBox.Text = speechRecognitionResult.Text;
speechButton.Content = "Speak";
speechButton.IsEnabled = true;
//speechInputSubmitted(speechRecognitionResult);
bool correctGuess = false;
try
{
correctGuess = mapLearner.guess(speechRecognitionResult);
}
catch (ArgumentNullException) { }
finally
{
AnswerSubmitted(correctGuess);
}
}
}
/// <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;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
this.speechRecognizer = new SpeechRecognizer(recognizerLanguage);
speechRecognizer.Timeouts.EndSilenceTimeout = new TimeSpan(0, 0, 0, 8);
speechRecognizer.Timeouts.BabbleTimeout = new TimeSpan(0, 0, 0, 3);
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
}
/// <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);
}
/// <summary>
/// Creates a SpeechRecognizer instance and initializes the grammar.
/// </summary>
private async Task InitializeRecognizer()
{
// 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();
// 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 InitializeTomaNota(Language recognizerLanguage)
{
if (speechRecognizerNotas != null)
{
//si vengo de una ejecución anterior, hacemos limpieza
speechRecognizerNotas.StateChanged -= SpeechRecognizer_StateChanged;
speechRecognizerNotas.ContinuousRecognitionSession.Completed -= ContinuousRecognitionSession_Completed;
speechRecognizerNotas.ContinuousRecognitionSession.ResultGenerated -= ContinuousRecognitionSession_ResultGenerated;
speechRecognizerNotas.HypothesisGenerated -= SpeechRecognizer_HypothesisGenerated;
this.speechRecognizerNotas.Dispose();
this.speechRecognizerNotas = null;
}
this.speechRecognizerNotas = new SpeechRecognizer(recognizerLanguage);
speechRecognizerNotas.StateChanged += SpeechRecognizer_StateChanged; //feedback al usuario
// en vez de gramática, aplicamos el caso de uso "Dictado"
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizerNotas.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult result = await speechRecognizerNotas.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
var messageDialog = new Windows.UI.Popups.MessageDialog(result.Status.ToString(), "Excepción inicializando la toma de notas: ");
await messageDialog.ShowAsync();
}
// nos registramos a los eventos
speechRecognizerNotas.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed; //no hubo éxito
speechRecognizerNotas.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated; //o entendió, o llegó basura
speechRecognizerNotas.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated; //se va alimentando de lo que va llegando para dar feedback
}
private async void InitializeSpeechRecognizer()
{
// Initialize SpeechRecognizer Object (Khởi tạo đối tượng SpeechRecognizer)
MyRecognizer = new SpeechRecognizer();
// Register Event Handlers
MyRecognizer.StateChanged += MyRecognizer_StateChanged;
MyRecognizer.ContinuousRecognitionSession.ResultGenerated += MyRecognizer_ResultGenerated;
// Create Grammar File Object (Tạo đối tượng Grammar từ mygrammar.xml đã xác định từ trước)
StorageFile GrammarContentFile = await Package.Current.InstalledLocation.GetFileAsync(@"mygrammar.xml");
// Add Grammar Constraint from Grammar File
SpeechRecognitionGrammarFileConstraint GrammarConstraint = new SpeechRecognitionGrammarFileConstraint(GrammarContentFile);
MyRecognizer.Constraints.Add(GrammarConstraint);
// Compile Grammar
SpeechRecognitionCompilationResult CompilationResult = await MyRecognizer.CompileConstraintsAsync();
// Write Debug Information
Debug.WriteLine("Status: " + CompilationResult.Status.ToString());
// If Compilation Successful, Start Continuous Recognition Session
if (CompilationResult.Status == SpeechRecognitionResultStatus.Success)
{
await MyRecognizer.ContinuousRecognitionSession.StartAsync();
}
}
private async Task InitializeRecognizer()
{
if (speechRecognizer != null)
{
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer();
//set of responses
string[] responses = { "hey sanya", "what's up sanya" };
//list constraint to the recognizer
var listConstraint = new SpeechRecognitionListConstraint(responses, "AssitantName");
speechRecognizer.Constraints.Add(listConstraint);
// Compile the dictation topic constraint, which optimizes for dictated speech.
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)
{
// Let the user know that the grammar didn't compile properly.
resultTextBlock.Visibility = Visibility.Visible;
resultTextBlock.Text = "Unable to compile grammar.";
}
}
/// <summary>
/// Starts the speech recognition
/// </summary>
public async void Start()
{
if (m_IsDisposed)
{
throw new ObjectDisposedException(nameof(DateTimeProvider));
}
var hasPermission = await HasMicrophonePermission();
if (!hasPermission)
{
throw new UnauthorizedAccessException("No access to microphone!");
}
var grammarFile = await Package.Current.InstalledLocation.GetFileAsync(GrammerFile);
var grammarConstraint = new SpeechRecognitionGrammarFileConstraint(grammarFile);
m_Recognizer.Constraints.Add(grammarConstraint);
var compilationResult = await m_Recognizer.CompileConstraintsAsync();
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
await m_Recognizer.ContinuousRecognitionSession.StartAsync();
}
}
/// <summary>
/// Creates a SpeechRecognizer instance and initializes the grammar.
/// </summary>
private async void InitializeRecognizer()
{
// Initialize the SRGS-compliant XML file.
// For more information about grammars for Windows apps and how to
// define and use SRGS-compliant grammars in your app, see
// https://msdn.microsoft.com/en-us/library/dn596121.aspx
StorageFile grammarContentFile = await Package.Current.InstalledLocation.GetFileAsync(@"SRGSColors.xml");
// Initialize the SpeechRecognizer and add the grammar.
recognizer = new SpeechRecognizer();
// Provide feedback to the user about the state of the recognizer.
recognizer.StateChanged += SpeechRecognizer_StateChanged;
SpeechRecognitionGrammarFileConstraint grammarConstraint = new SpeechRecognitionGrammarFileConstraint(grammarContentFile);
recognizer.Constraints.Add(grammarConstraint);
SpeechRecognitionCompilationResult compilationResult = await recognizer.CompileConstraintsAsync();
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
return;
}
// Set EndSilenceTimeout to give users more time to complete speaking a phrase.
recognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(1.2);
}
/// <summary>
/// Initializes the speech recognizer.
/// </summary>
public async void Initialize()
{
// Local recognizer
triggerRecognizer = new SpeechRecognizer();
var list = new SpeechRecognitionListConstraint(activationPhrases);
triggerRecognizer.Constraints.Add(list);
await triggerRecognizer.CompileConstraintsAsync();
triggerRecognizer.ContinuousRecognitionSession.Completed += localSessionCompleted;
triggerRecognizer.ContinuousRecognitionSession.ResultGenerated +=
LocalSessionResult;
//triggerRecognizer.HypothesisGenerated += CommandHypothesisGenerated;
// Command recognizer (web)
speechRecognizer = new SpeechRecognizer();
var result = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.ResultGenerated +=
CommandResultGenerated;
speechRecognizer.HypothesisGenerated += CommandHypothesisGenerated;
speechRecognizer.ContinuousRecognitionSession.Completed +=
CommandSessionCompleted;
await StartTriggerRecognizer();
OnResponseReceived(initText);
}
private async void InitSpeechRecognition()
{
try
{
if (speechRecognizerContinuous == null)
{
speechRecognizerContinuous = new SpeechRecognizer();
speechRecognizerContinuous.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<String>() { "Start Listening" }, "start"));
SpeechRecognitionCompilationResult contCompilationResult =
await speechRecognizerContinuous.CompileConstraintsAsync();
if (contCompilationResult.Status != SpeechRecognitionResultStatus.Success)
{
throw new Exception();
}
speechRecognizerContinuous.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
}
await speechRecognizerContinuous.ContinuousRecognitionSession.StartAsync();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
private async Task <SpeechRecognitionResult> SpeechRecognizeAsync()
{
if (_speechRecognizer == null)
{
// Create an instance of SpeechRecognizer.
_speechRecognizer = new SpeechRecognizer();
var songs = new[] { "order", "product", "manage", "capture", "home" };
// Generates the collection which we expect user will say one of.
// Create an instance of the constraint.
// Pass the collection and an optional tag to identify.
var playConstraint = new SpeechRecognitionListConstraint(songs);
// Add it into teh recognizer
_speechRecognizer.Constraints.Add(playConstraint);
// Then add the constraint for pausing and resuming.
//var pauseConstraint = new SpeechRecognitionListConstraint(new[] { "Pause", "Resume" }, "pauseAndResume");
//_speechRecognizer.Constraints.Add(pauseConstraint);
// Compile the dictation grammar by default.
await _speechRecognizer.CompileConstraintsAsync();
}
// Start recognition and return the result.
return(await _speechRecognizer.RecognizeWithUIAsync());
}
}//前台识别声音
public async Task <string> BackGroundRec()
{
string Result = "";
try
{
using (SpeechRecognizer recognizer = new SpeechRecognizer())
{
SpeechRecognitionCompilationResult compilationResult = await recognizer.CompileConstraintsAsync();
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
recognizer.UIOptions.IsReadBackEnabled = false;
recognizer.UIOptions.ShowConfirmation = false;
recognizer.UIOptions.AudiblePrompt = "我在听,请说...";
//SpeechRecognitionResult recognitionResult = await recognizer.RecognizeWithUIAsync();
SpeechRecognitionResult recognitionResult = await recognizer.RecognizeAsync();
if (recognitionResult.Status == SpeechRecognitionResultStatus.Success)
{
Result = recognitionResult.Text;
}
}
}
}
catch (Exception ex)
{
Result = ex.Message;
}
return(Result);
}//后台常驻声音
/// <summary>
/// Creates a SpeechRecognizer instance and initializes the grammar.
/// </summary>
private async Task InitializeRecognizer()
{
// 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 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 = @"Ex. ""weather for London""";
// 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.";
}
}
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;
}
private SpeechRecognitionService()
{
_recognizer = new SpeechRecognizer();
_recognizer.Constraints.Add(new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch,
"webSearch"));
_recognizer.CompileConstraintsAsync().AsTask().Wait();
_recognizer.ContinuousRecognitionSession.ResultGenerated += RecognitionFound;
}
public MainPage()
{
this.InitializeComponent();
var recognizer = new SpeechRecognizer();
var topicconstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.WebSearch, "Development");
recognizer.Constraints.Add(topicconstraint);
var result =
recognizer.CompileConstraintsAsync();
}
private async void listenIn() {
SpeechRecognizer speechRecognizer = new SpeechRecognizer();
speechRecognizer.Constraints.Add(new SpeechRecognitionListConstraint(new List<String>() { "note finished" }));
SpeechRecognitionCompilationResult comResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += Con_Result;
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
private async void listenIn()
{
SpeechRecognizer speechRecognizer = new SpeechRecognizer();
speechRecognizer.Constraints.Add(new SpeechRecognitionListConstraint(new List<String>() { "sponge in", "sponge out", "instrument in", "needle in","needle out", "instrument out", "going to close" }));
SpeechRecognitionCompilationResult comResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += Con_Result;
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
/// <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 MainWindow()
{
InitializeComponent();
recognizer = new SpeechRecognizer();
List<String> constraints = new List<string>();
//recognizer.Constraints.Add(new SpeechRecognitionListConstraint(constraints));
IAsyncOperation<SpeechRecognitionCompilationResult> op = recognizer.CompileConstraintsAsync();
resultGenerated = new TypedEventHandler<SpeechContinuousRecognitionSession, SpeechContinuousRecognitionResultGeneratedEventArgs>(UpdateTextBox);
recognizer.ContinuousRecognitionSession.ResultGenerated += resultGenerated;
OnStateChanged = new TypedEventHandler<SpeechRecognizer, SpeechRecognizerStateChangedEventArgs>(onStateChanged);
recognizer.StateChanged += OnStateChanged;
op.Completed += HandleCompilationCompleted;
}
async Task<bool> answerYN(string question)
{
var language = SpeechRecognizer.SystemSpeechLanguage;
speakString(question);
string[] yn = {"Yes", "No"};
SpeechRecognizer speechRecognizer = new SpeechRecognizer();
SpeechRecognitionListConstraint list = new SpeechRecognitionListConstraint(yn, "yesOrNo");
speechRecognizer.Constraints.Add(list);
await speechRecognizer.CompileConstraintsAsync();
SpeechRecognitionResult answerResult = await speechRecognizer.RecognizeWithUIAsync();
if (answerResult.Text == "Yes")
return true;
else
return false;
}
public async void StartListening(object sender, EventArgs e)
{
try
{
//args = e;
speechRecognizer = new SpeechRecognizer();
StorageFolder folder = ApplicationData.Current.LocalFolder;
var uri = new System.Uri("ms-appx:///Assets/TestGrammar.xml");
var file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(uri);
speechRecognizer.Constraints.Clear();
speechRecognizer.Constraints.Add(new SpeechRecognitionGrammarFileConstraint(file));
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
throw new Exception("Grammar compilation failed");
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
Debug.WriteLine("Listener initialized");
isListening = true;
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
uri = new System.Uri("ms-appx:///Assets/ResponseTemplates.xml");
file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(uri);
var t = new DialogueManager(file);
var qq = t.GenerateResponse(new Dictionary<string, string>() { { "ACTION", "DESTINATION" }, { "DESTINATION", "COFFEE_SHOP" } }, ref args);
Debug.WriteLine(qq);
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
Speak(qq);
});
}
catch (Exception ex)
{
isListening = false;
}
//return "I was returned";
}
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");
}
}
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 static Task<SpeechRecognizer> InitRecognizer()
{
try
{
if (null != recognizer)
{
recognizer.Dispose();
recognizer = null;
}
recognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
recognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<string>()
{
speechResourceMap.GetValue("account page", speechContext).ValueAsString,
speechResourceMap.GetValue("audit page", speechContext).ValueAsString,
speechResourceMap.GetValue("finace page", speechContext).ValueAsString,
speechResourceMap.GetValue("transfer page", speechContext).ValueAsString
}, "goto"));
SpeechRecognitionCompilationResult compilationResult = await recognizer.CompileConstraintsAsync();
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
recognizer.Dispose();
recognizer = null;
}
//string uiOptionsText = string.Format("Try saying '{0}', '{1}' or '{2}'",
// speechResourceMap.GetValue("account page", speechContext).ValueAsString,
// speechResourceMap.GetValue("audit page", speechContext).ValueAsString,
// speechResourceMap.GetValue("audit page", speechContext).ValueAsString);
//recognizer.UIOptions.ExampleText = uiOptionsText;
return recognizer;
}
catch(Exception e)
{
return null;
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
MediaElementCtrl.MediaEnded += MediaElementCtrl_MediaEnded;
this.dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
this.speechRecognizer = new SpeechRecognizer();
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
#region TTS
try
{
_voice = (from voiceInformation
in Windows.Media.SpeechSynthesis.SpeechSynthesizer.AllVoices
select voiceInformation).First();
_speechSynthesizer = new Windows.Media.SpeechSynthesis.SpeechSynthesizer();
_speechSynthesizer.Voice = _voice;
}
catch (Exception exception)
{
var messageDialog = new Windows.UI.Popups.MessageDialog(exception.Message, "Exception");
messageDialog.ShowAsync().GetResults();
}
#endregion
StartConversation();
//#if DEBUG
// _questions.Last().Value = "1";
// EndConversation();
// return;
//#endif
}
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 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 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 Task InitContiniousRecognition()
{
try
{
if (speechRecognizerContinuous == null)
{
speechRecognizerContinuous = new SpeechRecognizer();
speechRecognizerContinuous.Constraints.Add(new SpeechRecognitionListConstraint(new List<String>() { "Take a Picture", "Reset", "How Old" }, "start"));
SpeechRecognitionCompilationResult contCompilationResult = await speechRecognizerContinuous.CompileConstraintsAsync();
if (contCompilationResult.Status != SpeechRecognitionResultStatus.Success)
{
throw new Exception();
}
speechRecognizerContinuous.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
}
await speechRecognizerContinuous.ContinuousRecognitionSession.StartAsync();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
public async Task FindByVoiceAsync()
{
IsListening = true;
_speechRecognizer = new SpeechRecognizer();
var wordsFromJson = _agendaService.GetWordsFromJson().Where(w => w.Length >= 3).Distinct().ToList();
_speechRecognizer.Constraints.Add(new SpeechRecognitionListConstraint(wordsFromJson, "keyword"));
await _speechRecognizer.CompileConstraintsAsync();
_speechRecognizer.ContinuousRecognitionSession.ResultGenerated +=
ContinuousRecognitionSession_ResultGenerated;
_speechRecognizer.HypothesisGenerated += SpeechRecognizerHypothesisGenerated;
await _speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
// Note: to keep the amount of demo code to a minimum,
// this example does not currently handle multitasking or OnNavigatedFrom events.
// Get UI dispatcher for accessing the UI from the background thread
// Callbacks from the speech recognition API will happen in a background thread.
_dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// Initialize the speech recognizer
_speechRecognizer = new SpeechRecognizer();
// Compile the speech recognizer constraints using the default
await _speechRecognizer.CompileConstraintsAsync();
// Register for the callback when a result of the Continuous Recognition Session was generated.
// In this method, we need to save the result text and confidence score.
// If the user briefly pauses speaking, there will be multiple callbacks to this method during
// the 7 seconds, each containing the current fragment of text.
_speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
// Register for the callback when the Continuous Recognition Session completes.
// In the best case, this happens because our app stopped it after 7 seconds.
// However, it can also happen if there is a timeout (the user doesn't speak) or if there
// is a configuration issue.
_speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
}
private async void lineRecog()
{
SpeechRecognizer speechRecognizer = new SpeechRecognizer();
// Compile the default dictionary
SpeechRecognitionCompilationResult compilationResult =
await speechRecognizer.CompileConstraintsAsync();
// Start recognizing
// Note: you can also use RecognizeWithUIAsync()
SpeechRecognitionResult speechRecognitionResult = await speechRecognizer.RecognizeAsync();
result = speechRecognitionResult.Text;
}
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();
}
/// <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.ContinuousRecognitionSession.Completed -= ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated -= ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.StateChanged -= SpeechRecognizer_StateChanged;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
try {
// Initialize the SRGS-compliant XML file.
// For more information about grammars for Windows apps and how to
// define and use SRGS-compliant grammars in your app, see
// https://msdn.microsoft.com/en-us/library/dn596121.aspx
// determine the language code being used.
string languageTag = recognizerLanguage.LanguageTag;
string fileName = String.Format("SRGS\\{0}\\SRGSColors.xml", languageTag);
StorageFile grammarContentFile = await Package.Current.InstalledLocation.GetFileAsync(fileName);
resultTextBlock.Text = speechResourceMap.GetValue("SRGSHelpText", speechContext).ValueAsString;
// Initialize the SpeechRecognizer and add the grammar.
speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// Provide feedback to the user about the state of the recognizer. This can be used to provide
// visual feedback to help the user understand whether they're being heard.
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
SpeechRecognitionGrammarFileConstraint grammarConstraint = new SpeechRecognitionGrammarFileConstraint(grammarContentFile);
speechRecognizer.Constraints.Add(grammarConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile them.
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
// Disable the recognition button.
btnContinuousRecognize.IsEnabled = false;
// Let the user know that the grammar didn't compile properly.
resultTextBlock.Text = "Unable to compile grammar.";
}
else
{
// Set EndSilenceTimeout to give users more time to complete speaking a phrase.
speechRecognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(1.2);
// Handle continuous recognition events. Completed fires when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or the garbage rule is hit.
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
btnContinuousRecognize.IsEnabled = true;
resultTextBlock.Text = speechResourceMap.GetValue("SRGSHelpText", speechContext).ValueAsString;
resultTextBlock.Visibility = Visibility.Visible;
}
}
catch (Exception ex)
{
if ((uint)ex.HResult == HResultRecognizerNotFound)
{
btnContinuousRecognize.IsEnabled = false;
resultTextBlock.Visibility = Visibility.Visible;
resultTextBlock.Text = "Speech Language pack for selected language not installed.";
}
else
{
var messageDialog = new Windows.UI.Popups.MessageDialog(ex.Message, "Exception");
await messageDialog.ShowAsync();
}
}
}
/// <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.";
}
}
/// <summary>
/// Initializes speech recognition and begins listening.
/// </summary>
/// <param name="system">
/// The <see cref="CelestialSystem"/> used to build voice commands and return results.
/// </param>
/// <returns>
/// A <see cref="Task"/> that yields the result of the operation.
/// </returns>
public async Task<SpeechRecognitionResultStatus> InitializeAsync(CelestialSystem system)
{
// Validate
if (isInitialized) { throw new InvalidOperationException("Already initialized."); }
if (system == null) throw new ArgumentNullException("system");
// Store
this.system = system;
// Create recognizer
recognizer = new SpeechRecognizer();
// Configure to never stop listening
recognizer.ContinuousRecognitionSession.AutoStopSilenceTimeout = TimeSpan.MaxValue;
// Subscribe to events
recognizer.StateChanged += RecognizerStateChanged;
recognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
recognizer.ContinuousRecognitionSession.ResultGenerated += RecognizerResultGenerated;
// Load constraint
var constraint = await LoadDynamicConstraintAsync();
// Add constraint to recognizer
recognizer.Constraints.Add(constraint);
// Compile
var compileResult = await recognizer.CompileConstraintsAsync();
Debug.WriteLine("Grammar Compiled: " + compileResult.Status.ToString());
// We're initialized now
isInitialized = true;
// If successful start recognition
if (compileResult.Status == SpeechRecognitionResultStatus.Success)
{
await recognizer.ContinuousRecognitionSession.StartAsync(SpeechContinuousRecognitionMode.Default);
}
// Return the result
return compileResult.Status;
}
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);
}
}
/// <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;
}
try
{
// 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 list constraint to the recognizer.
speechRecognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<string>()
{
speechResourceMap.GetValue("ListGrammarGoHome", speechContext).ValueAsString
}, "Home"));
speechRecognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<string>()
{
speechResourceMap.GetValue("ListGrammarGoToContosoStudio", speechContext).ValueAsString
}, "GoToContosoStudio"));
speechRecognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<string>()
{
speechResourceMap.GetValue("ListGrammarShowMessage", speechContext).ValueAsString,
speechResourceMap.GetValue("ListGrammarOpenMessage", speechContext).ValueAsString
}, "Message"));
speechRecognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<string>()
{
speechResourceMap.GetValue("ListGrammarSendEmail", speechContext).ValueAsString,
speechResourceMap.GetValue("ListGrammarCreateEmail", speechContext).ValueAsString
}, "Email"));
speechRecognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<string>()
{
speechResourceMap.GetValue("ListGrammarCallNitaFarley", speechContext).ValueAsString,
speechResourceMap.GetValue("ListGrammarCallNita", speechContext).ValueAsString
}, "CallNita"));
speechRecognizer.Constraints.Add(
new SpeechRecognitionListConstraint(
new List<string>()
{
speechResourceMap.GetValue("ListGrammarCallWayneSigmon", speechContext).ValueAsString,
speechResourceMap.GetValue("ListGrammarCallWayne", speechContext).ValueAsString
}, "CallWayne"));
// RecognizeWithUIAsync allows developers to customize the prompts.
string uiOptionsText = string.Format("Try saying '{0}', '{1}' or '{2}'",
speechResourceMap.GetValue("ListGrammarGoHome", speechContext).ValueAsString,
speechResourceMap.GetValue("ListGrammarGoToContosoStudio", speechContext).ValueAsString,
speechResourceMap.GetValue("ListGrammarShowMessage", speechContext).ValueAsString);
speechRecognizer.UIOptions.ExampleText = uiOptionsText;
helpTextBlock.Text = string.Format("{0}\n{1}",
speechResourceMap.GetValue("ListGrammarHelpText", speechContext).ValueAsString,
uiOptionsText);
// 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.";
}
else
{
btnRecognizeWithUI.IsEnabled = true;
btnRecognizeWithoutUI.IsEnabled = true;
resultTextBlock.Visibility = Visibility.Collapsed;
}
}
catch(Exception ex)
{
if((uint)ex.HResult == HResultRecognizerNotFound)
{
btnRecognizeWithUI.IsEnabled = false;
btnRecognizeWithoutUI.IsEnabled = false;
resultTextBlock.Visibility = Visibility.Visible;
resultTextBlock.Text = "Speech Language pack for selected language not installed.";
}
else
{
var messageDialog = new Windows.UI.Popups.MessageDialog(ex.Message, "Exception");
await messageDialog.ShowAsync();
}
}
}
private async Task InitializeRecognizer()
{
bool permissionGained = await RequestMicrophonePermission();
if (!permissionGained)
{
stat.Text = "No mic permission";
return;
}
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer();
StorageFile grammarContentFile = await Package.Current.InstalledLocation.GetFileAsync(@"grammar.xml");
SpeechRecognitionGrammarFileConstraint grammarConstraint = new SpeechRecognitionGrammarFileConstraint(grammarContentFile);
speechRecognizer.Constraints.Add(grammarConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
stat.Text = "Error:" + compilationResult.Status.ToString();
return;
}
// Set EndSilenceTimeout to give users more time to complete speaking a phrase.
speechRecognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(1.2);
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
public override async Task InitializeAsync()
{
if (speechRecognizer == null)
{
try
{
var recognizer = new SpeechRecognizer(ConvertAILangToSystem(config.Language));
// INFO: Dictation is default Constraint
//var webSearchGrammar = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
//recognizer.Constraints.Add(webSearchGrammar);
await recognizer.CompileConstraintsAsync();
lock (speechRecognizerLock)
{
if (speechRecognizer == null)
{
speechRecognizer = recognizer;
}
}
}
catch (Exception e)
{
if ((uint)e.HResult == HRESULT_LANG_NOT_SUPPORTED)
{
throw new AIServiceException(string.Format("Specified language {0} not supported or not installed on device", config.Language.code), e);
}
throw;
}
}
}
