public override async Task <SpeechEnroller.Result> TrainAsync()
{
if (IsSessionOpen && !IsSessionClosing)
{
IsSessionClosing = true;
EnrollResults.Clear();
Content.Clear();
Uri uri = Configuration.Server.BuildEndpoint(URI_PATH_TRAIN);
Logger?.LogDebug("SpeechEnroller_HttpClient_Version1.TrainAsync(): URI: " + uri.ToString());
using (var request = BuildRequest(CallMode.Train, uri))
{
try
{
await HandleResponse(CallMode.Train, request, await mHttpClient.SendAsync(request));
}
catch (HttpRequestException ex)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(ex);
}
return(EnrollResult);
}
}
return(EnrollResult = SpeechEnroller.Result.Invalid);
}
public override SpeechEnroller.Result Post()
{
if (IsSessionOpen && !IsSessionClosing)
{
EnrollResults.Clear();
Uri uri = Configuration.Server.BuildEndpoint(URI_PATH_PROCESS);
Logger?.LogDebug("SpeechEnroller_HttpClient_Version1.Post(): URI: " + uri.ToString());
using (var request = BuildRequest(CallMode.Process, uri))
{
try
{
var responseTask = mHttpClient.SendAsync(request);
responseTask.RunSynchronously();
var resultTask = HandleResponse(CallMode.Process, request, responseTask.Result);
resultTask.RunSynchronously();
}
catch (HttpRequestException ex)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(ex);
}
return(EnrollResult);
}
}
return(EnrollResult = SpeechEnroller.Result.Invalid);
}
public override void Cancel(string reason, SpeechEnroller.CancelCallback callback)
{
if (IsSessionOpen && !IsSessionClosing)
{
IsSessionClosing = true;
EnrollResults.Clear();
Content.Clear();
if (string.IsNullOrEmpty(reason))
{
reason = "Unknown";
}
else
{
reason = reason.Replace(' ', '-').Substring(0, System.Math.Min(reason.Length, 64));
}
Uri uri = Configuration.Server.BuildEndpoint(URI_PATH_CANCEL, reason);
Logger?.LogDebug("SpeechEnroller_HttpClient_Version1.Cancel(callback): URI: " + uri.ToString());
using (var request = BuildRequest(CallMode.Cancel, uri))
{
var task = mHttpClient.SendAsync(request).ContinueWith((requestTask) => {
if (requestTask.IsFaulted)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(requestTask.Exception);
callback?.Invoke();
return;
}
HandleResponse(CallMode.Cancel, request, requestTask.Result).ContinueWith((responseTask) => {
if (responseTask.IsFaulted)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(responseTask.Exception);
callback?.Invoke();
return;
}
callback?.Invoke();
});
});
if (task.IsFaulted)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(task.Exception);
callback?.Invoke();
}
return;
}
}
EnrollResult = SpeechEnroller.Result.Invalid;
callback?.Invoke();
}
public override void Train(SpeechEnroller.TrainCallback callback)
{
if (IsSessionOpen && !IsSessionClosing)
{
IsSessionClosing = true;
EnrollResults.Clear();
Content.Clear();
Uri uri = Configuration.Server.BuildEndpoint(URI_PATH_TRAIN);
Logger?.LogDebug("SpeechEnroller_HttpClient_Version1.Train(callback): URI: " + uri.ToString());
using (var request = BuildRequest(CallMode.Train, uri))
{
var task = mHttpClient.SendAsync(request).ContinueWith((requestTask) => {
if (requestTask.IsFaulted)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(requestTask.Exception);
callback?.Invoke(EnrollResult);
return;
}
HandleResponse(CallMode.Train, request, requestTask.Result).ContinueWith((responseTask) => {
if (responseTask.IsFaulted)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(responseTask.Exception);
callback?.Invoke(EnrollResult);
return;
}
callback?.Invoke(EnrollResult);
});
});
if (task.IsFaulted)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(task.Exception);
callback?.Invoke(EnrollResult);
}
return;
}
}
callback?.Invoke(EnrollResult = SpeechEnroller.Result.Invalid);
}
public override bool Cancel(string reason)
{
if (IsSessionOpen && !IsSessionClosing)
{
IsSessionClosing = true;
EnrollResults.Clear();
Content.Clear();
if (string.IsNullOrEmpty(reason))
{
reason = "Unknown";
}
else
{
reason = reason.Replace(' ', '-').Substring(0, System.Math.Min(reason.Length, 64));
}
Uri uri = Configuration.Server.BuildEndpoint(URI_PATH_CANCEL, reason);
Logger?.LogDebug("SpeechEnroller_HttpClient_Version1.Cancel(): URI: " + uri.ToString());
using (var request = BuildRequest(CallMode.Cancel, uri))
{
try
{
var responseTask = mHttpClient.SendAsync(request);
responseTask.RunSynchronously();
var resultTask = HandleResponse(CallMode.Cancel, request, responseTask.Result);
resultTask.RunSynchronously();
return(resultTask.Result);
}
catch (HttpRequestException ex)
{
EnrollResult = SpeechEnroller.Result.Timeout;
Logger?.LogError(ex);
}
}
}
return(false);
}
protected void ResetEnroller()
{
SessionId = "";
Codec = WaveFormatEncoding.Unknown;
Profiles.Clear();
EnrollResults.Clear();
EnrollResult = SpeechEnroller.Result.NeedMore;
MetaData.Clear();
ExtraData.Clear();
Content.Clear();
CookieContainer = new CookieContainer();
TotalSnippetsSent = 0;
TotalAudioBytesSent = 0;
TotalProcessCalls = 0;
SpeechRequired = 0;
SpeechExtracted = 0;
IsSessionOpen = false;
IsSessionClosing = false;
IsTooSoft = false;
IsTooLoud = false;
}
protected void AddResult(uint index, string name, SpeechEnroller.InstanceResult result)
{
SpeechEnroller.Profile profile = Profiles[index];
if (result.SpeechExtracted.HasValue)
{
result.SpeechTrained = 0.0;
if (result.SpeechExtracted.Value >= profile.MinimumSecondsOfSpeech)
{
result.Result = SpeechEnroller.Result.Success;
}
else
{
result.Result = SpeechEnroller.Result.NeedMore;
}
}
else if (result.SpeechTrained.HasValue)
{
result.Result = SpeechEnroller.Result.Success;
result.SpeechExtracted = 0.0;
}
else
{
// Error
result.Result = SpeechEnroller.Result.Invalid;
}
Logger?.LogDebug("SpeechEnrollerBase.AddResult(): {0} - ErrorCode: {1}", name, result.ErrorCode);
Logger?.LogDebug("SpeechEnrollerBase.AddResult(): {0} - SpeechExtracted: {1}", name, result.SpeechExtracted);
Logger?.LogDebug("SpeechEnrollerBase.AddResult(): {0} - SpeechTrained: {1}", name, result.SpeechTrained);
Logger?.LogDebug("SpeechEnrollerBase.AddResult(): {0} - Result: {1}", name, result.Result);
foreach (var extra in result.Extra)
{
Logger?.LogDebug("SpeechEnrollerBase.AddResult(): {0} - {1}: {2}", name, extra.Key, extra.Value);
}
EnrollResults.Add(name, result);
}
private async Task <bool> HandleResponse(CallMode mode, HttpRequestMessage request, HttpResponseMessage response)
{
Content.Clear();
ExtraData.Clear();
if (response == null)
{
Logger?.LogError("SpeechEnroller_HttpClient_Version1.HandleResponse(): Timeout occurred");
EnrollResult = SpeechEnroller.Result.Timeout;
return(false);
}
try
{
HttpStatusCode code = response.StatusCode;
string description = response.ReasonPhrase;
Logger?.LogDebug($"SpeechEnroller_HttpClient_Version1.HandleResponse(): Http Status Code: {code}");
Logger?.LogDebug($"SpeechEnroller_HttpClient_Version1.HandleResponse(): Http Status Description: {description}");
if (code == HttpStatusCode.OK)
{
if (mode == CallMode.Start)
{
if (!response.Headers.TryGetValues(SpeechApi.SESSION_ID, out var sessionValue))
{
Logger?.LogError("SpeechEnroller_HttpClient_Version1.HandleResponse(): Invalid start response, no Vv-Session-Id");
return(false);
}
SessionId = sessionValue.FirstOrDefault();
if (string.IsNullOrEmpty(SessionId))
{
Logger?.LogError("SpeechEnroller_HttpClient_Version1.HandleResponse(): Invalid start response, empty Vv-Session-Id");
return(false);
}
IsSessionOpen = true;
}
else if (mode == CallMode.Train)
{
SessionId = "";
IsSessionOpen = false;
}
else if (mode == CallMode.Cancel)
{
SessionId = "";
IsSessionOpen = false;
return(true);
}
}
if (response.Headers.TryGetValues(SpeechApi.SET_COOKIE, out var newCookies))
{
foreach (var item in SetCookieHeaderValue.ParseList(newCookies.ToList()))
{
var uri = new Uri(request.RequestUri, item.Path.Value);
Logger?.LogDebug("{0}: {1} - {2} - {3}", SpeechApi.SET_COOKIE, item.Name.Value, item.Value.Value, item.Path.Value);
CookieContainer.Add(uri, new Cookie(item.Name.Value, item.Value.Value, item.Path.Value));
}
}
if (response.Content == null)
{
Logger?.LogError("SpeechEnroller_HttpClient_Version1.HandleResponse(): Expected Content Type: 'application/json'. Actual Content Type: 'Empty'");
return(false);
}
else if (!response.Content.Headers.ContentType.MediaType.Equals("application/json"))
{
Logger?.LogError("SpeechEnroller_HttpClient_Version1.HandleResponse(): Expected Content Type: 'application/json'. Actual Content Type: '{0}'", response.Content.Headers.ContentType.MediaType);
return(false);
}
var content = await response.Content.ReadAsStringAsync();
if (content == null || content.Length == 0)
{
Logger?.LogError("SpeechEnroller_HttpClient_Version1.HandleResponse(): Expected Content Data: Length 0");
return(false);
}
Logger?.LogDebug("SpeechEnroller_HttpClient_Version1.HandleResponse(): Http Content: {0}", content);
SpeechEnroller_Version1_Response version1Response = JsonConvert.DeserializeObject <SpeechEnroller_Version1_Response>(content);
if (code == HttpStatusCode.OK)
{
switch (mode)
{
case CallMode.Profile:
if (version1Response.EnrollProfile != null)
{
mLastProfileIndex = AddProfile(version1Response.EnrollProfile.Index, version1Response.EnrollProfile.Profile);
}
break;
case CallMode.Start:
if (version1Response.EnrollProfile != null)
{
mLastProfileIndex = AddProfile(version1Response.EnrollProfile.Index, version1Response.EnrollProfile.Profile);
}
if (version1Response.ResultData != null)
{
foreach (var kv in version1Response.ResultData)
{
ExtraData.Add(kv.Key, kv.Value);
}
}
break;
case CallMode.Process:
if (version1Response.EnrollResults != null)
{
foreach (var kv in version1Response.EnrollResults)
{
AddResult(kv.Value.Index, kv.Key, kv.Value.Instance);
}
if (!string.IsNullOrEmpty(ClientId) && EnrollResults.ContainsKey(ClientId.ToLower()))
{
SpeechEnroller.InstanceResult result = EnrollResults[ClientId.ToLower()];
SpeechTrained = 0;
if (result.SpeechExtracted.HasValue)
{
SpeechExtracted = result.SpeechExtracted.Value;
}
EnrollResult = result.Result;
}
else
{
SpeechExtracted = 0;
SpeechTrained = 0;
EnrollResult = SpeechEnroller.Result.Unknown;
}
}
if (version1Response.ResultData != null)
{
foreach (var kv in version1Response.ResultData)
{
ExtraData.Add(kv.Key, kv.Value);
}
}
break;
case CallMode.Train:
if (version1Response.EnrollResults != null)
{
foreach (var kv in version1Response.EnrollResults)
{
AddResult(kv.Value.Index, kv.Key, kv.Value.Instance);
}
if (!string.IsNullOrEmpty(ClientId) && EnrollResults.ContainsKey(ClientId.ToLower()))
{
SpeechEnroller.InstanceResult result = EnrollResults[ClientId.ToLower()];
SpeechExtracted = 0;
if (result.SpeechTrained.HasValue)
{
SpeechTrained = result.SpeechTrained.Value;
}
EnrollResult = result.Result;
}
else
{
SpeechExtracted = 0;
SpeechTrained = 0;
EnrollResult = SpeechEnroller.Result.Unknown;
}
}
if (version1Response.ResultData != null)
{
foreach (var kv in version1Response.ResultData)
{
ExtraData.Add(kv.Key, kv.Value);
}
}
break;
}
return(true);
}
else
{
if (version1Response.Error.HasValue)
{
EnrollResult = GetErrorResult(version1Response.Error.Value);
}
else
{
EnrollResult = SpeechEnroller.Result.Unknown;
}
if (EnrollResult == SpeechEnroller.Result.NeedMore)
{
if (IsTooSoft)
{
EnrollResult = SpeechEnroller.Result.TooSoft;
}
else if (IsTooLoud)
{
EnrollResult = SpeechEnroller.Result.TooLoud;
}
}
else if (EnrollResult == SpeechEnroller.Result.TooSoft)
{
IsTooSoft = true;
}
else if (EnrollResult == SpeechEnroller.Result.TooLoud)
{
IsTooLoud = true;
}
Logger?.LogError(
"SpeechEnroller_HttpClient_Version1.HandleResponse(): Error detected.\r\n\tUri: {0}\r\n\tResult: {1}\r\n\tCode: {2}\r\n\tDescription: {3}",
request.RequestUri,
EnrollResult,
version1Response.Error.HasValue ? "" + version1Response.Error.Value + "" : "?",
version1Response.Description);
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
}
