/// <summary>
/// On speech recognizer ready for update callback, called by recognition engine
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void RecognizerUpdateReachedHandler(object sender, RecognizerUpdateReachedEventArgs args)
{
// Unload currently loaded grammar
if (this.state.Grammar != null)
{
try
{
this.state.Recognizer.UnloadGrammar(this.state.Grammar);
}
catch (Exception) {}
}
if (grammarToLoad != null)
{
// Load new grammar asynchronously
try
{
this.state.Recognizer.LoadGrammarAsync(grammarToLoad);
}
catch (Exception exception)
{
LogWarning(exception);
loadGrammarResponsePort.Post(exception);
}
}
else
{
// Did not need to load a new grammar, done here
loadGrammarResponsePort.Post(SuccessResult.Instance);
}
}
private void SpeechGrammarChange(object sender, RecognizerUpdateReachedEventArgs e)
{
ambrRecognitionEngine.UnloadAllGrammars();
if (e.UserToken == null)
{
//reset to the old grammar
recognizeItemList = false;
InstallDefaultSpeechGrammar();
}
else if (e.UserToken.GetType() == typeof(XmlDocument))
{
//We theoretically have a grammar we can use...
recognizeItemList = true;
var memoryStream = new MemoryStream();
((XmlDocument)e.UserToken).Save(memoryStream);
memoryStream.Position = 0;//reset the stream position to 0
speechGrammar = new Grammar(memoryStream);
ambrRecognitionEngine.LoadGrammar(speechGrammar);
}
else
{
//something is wrong here...
throw new ArgumentException("User token was not null or XML");
}
}
// callback when recogniser is ready for grammar updates
private void Recognizer_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
var todelete = new List <string>();
foreach (var kvp in currentgrammar)
{
if (!updategrammar.ContainsKey(kvp.Key)) // any keys in currentgrammar not in update list, remove
{
//System.Diagnostics.Debug.WriteLine($"{AppTicks.MSd} VR Remove {kvp.Key}");
foreach (var g in kvp.Value)
{
recognizer.UnloadGrammar(g);
}
todelete.Add(kvp.Key);
}
else
{
//System.Diagnostics.Debug.WriteLine($"{AppTicks.MSd} VR Keep {kvp.Key}");
}
}
foreach (var d in todelete) // clean up dictionary
{
currentgrammar.Remove(d);
}
foreach (var kvp in updategrammar)
{
if (kvp.Value != null) // may be null, meaning its already there, if not, add
{
//System.Diagnostics.Debug.WriteLine($"{AppTicks.MSd} VR Add {kvp.Key}");
foreach (var g in kvp.Value)
{
recognizer.LoadGrammar(g);
}
currentgrammar.Add(kvp.Key, kvp.Value);
}
}
{
System.Diagnostics.Debug.WriteLine($"{AppTicks.MSd} VR List");
List <Grammar> glist = new List <Grammar>(recognizer.Grammars);
foreach (var g in glist)
{
System.Diagnostics.Debug.Write($"{g.Name}, ");
}
System.Diagnostics.Debug.WriteLine($"");
}
updatinggrammar = false;
}
private void OnUpdateRecognizer(object sender, RecognizerUpdateReachedEventArgs e)
{
lock (mLock)
{
foreach (var grammar in mGrammarQueue)
{
mRecognizer.LoadGrammarAsync(grammar);
}
mGrammarQueue.Clear();
}
}
private static void RegisteredEngine_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
DataStore.AddToMessageDump("SRE Update reached:");
string qualifier;
List <Grammar> grammars = new List <Grammar>(registeredEngine.Grammars);
foreach (Grammar g in grammars)
{
qualifier = (g.Enabled) ? "enabled" : "disabled";
DataStore.AddToMessageDump(string.Format("{0} grammar is loaded and {1}.", g.Name, qualifier));
}
}
/// <summary>
/// Requested by `SetGrammars()` - now ready to update.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args (`UserToken` expected to contain grammars).</param>
private void OnRecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
if (e.UserToken is IEnumerable <Grammar> grammars)
{
this.speechRecognitionEngine.UnloadAllGrammars();
foreach (var g in grammars)
{
this.speechRecognitionEngine.LoadGrammar(g);
}
}
DateTime originatingTime = this.streamStartTime + e.AudioPosition;
this.PostWithOriginatingTimeConsistencyCheck(this.RecognizerUpdateReached, e, originatingTime);
}
// At the update, get the names and enabled status of the currently loaded grammars.
public static void RecognizerUpdateReachedHandler(
object sender, RecognizerUpdateReachedEventArgs e)
{
//Thread.Sleep(1000);
Console.WriteLine("Speech Processor: Now listing grammars ....");
string qualifier;
List<Grammar> grammars = new List<Grammar>(recognizer.Grammars);
foreach (Grammar g in grammars)
{
qualifier = (g.Enabled) ? "enabled" : "disabled";
Console.WriteLine("Grammar {0} is loaded and is {1}.",
g.Name, qualifier);
}
}
/// <summary>
/// Requested by `SetGrammars()` - now ready to update
/// </summary>
/// <param name="sender">Event sender</param>
/// <param name="e">Event args (`UserToken` expected to contain grammars)</param>
private void OnRecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
var grammars = e.UserToken as IEnumerable <Grammar>;
if (grammars != null)
{
this.speechRecognitionEngine.UnloadAllGrammars();
foreach (var g in grammars)
{
this.speechRecognitionEngine.LoadGrammar(g);
}
}
DateTime originatingTime = this.streamStartTime + e.AudioPosition;
this.recognizerUpdateReached.Post(e, originatingTime);
}
// At the update, get the names and enabled status of the currently loaded grammars.
public static void RecognizerUpdateReachedHandler(
object sender, RecognizerUpdateReachedEventArgs e)
{
//Thread.Sleep(1000);
Console.WriteLine("Speech Processor: Now listing grammars ....");
string qualifier;
List <Grammar> grammars = new List <Grammar>(recognizer.Grammars);
foreach (Grammar g in grammars)
{
qualifier = (g.Enabled) ? "enabled" : "disabled";
Console.WriteLine("Grammar {0} is loaded and is {1}.",
g.Name, qualifier);
}
}
private void SpeechRecEngine_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
switch (mode)
{
case UpdateMode.Replace:
SpeechRecEngine.UnloadAllGrammars();
SpeechRecEngine.LoadGrammarAsync(newGrammar); // Set up new contents to recognize
break;
case UpdateMode.Append:
SpeechRecEngine.LoadGrammar(newGrammar);
break;
default:
break;
}
}
private void RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
log.Debug("RecognizerUpdateReached!");
GrammarUpdateObject guo = (GrammarUpdateObject)e.UserToken;
Grammar grammar = guo.grammarToUpdate;
float confidence = guo.confidence;
// update grammar
if (grammarMap.ContainsKey(grammar.Name))
{
s_recognizer.UnloadGrammar(grammarMap[grammar.Name]);
}
s_recognizer.LoadGrammar(grammar);
grammarMap[grammar.Name] = grammar;
// update confidence if it has value
if (confidence > 0)
{
confidenceMap[grammar.Name] = confidence;
}
}
public void recognizer_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
if (done == false)
{
if (grammarLoaded == true)
{
try
{
sre.UnloadGrammar(loaded);
Console.WriteLine("Grammar unloaded");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
sre.LoadGrammar(toLoad);
Console.WriteLine("Grammar loaded");
grammarLoaded = true;
done = true;
loaded = toLoad;
}
}
private void RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
Debug.WriteLine("Recognizer update reached.");
}
private void RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
Debug.WriteLine("Recognizer update reached: " + e.AudioPosition + " " + e.UserToken);
}
void RecognitionEngine_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
if (toReloadTheGrammars)
{
LoadPluginsGrammar(mPluginHandler);
toReloadTheGrammars = false;
}
}
void sre_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
MessageBox.Show("Update?");
}
private static void RegisteredEngine_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
DataStore.AddToMessageDump("SRE Update reached:");
string qualifier;
List<Grammar> grammars = new List<Grammar>(registeredEngine.Grammars);
foreach (Grammar g in grammars)
{
qualifier = (g.Enabled) ? "enabled" : "disabled";
DataStore.AddToMessageDump(string.Format("{0} grammar is loaded and {1}.",g.Name, qualifier));
}
}
private static void Recognizer_RecognizerUpdateReached(object sender, RecognizerUpdateReachedEventArgs e)
{
Console.WriteLine("OK");
}
private void OnUpdateRecognizer(object sender, RecognizerUpdateReachedEventArgs e)
{
lock (mLock)
{
foreach (var grammar in mGrammarQueue)
{
mRecognizer.LoadGrammarAsync(grammar);
}
mGrammarQueue.Clear();
}
}
