/// <summary>
/// Dequeue the first record
/// </summary>
public static RequestRecord DequeueRequestRecord(string queueName)
{
List <RequestRecord> requests = new List <RequestRecord>();
DataContractJsonSerializer dc = new DataContractJsonSerializer(requests.GetType());
using (IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication())
{
lock (fileLocks[queueName])
{
using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(QueueFilename(queueName), FileMode.Open, file))
{
try
{
// if the file opens, read the contents
requests = dc.ReadObject(stream) as List <RequestRecord>;
if (requests.Count > 0)
{
RequestRecord record = requests[0];
requests.Remove(record); // remove the first entry
stream.SetLength(0);
stream.Position = 0;
dc.WriteObject(stream, requests);
record.DeserializeBody();
return(record);
}
else
{
return(null);
}
}
catch (Exception ex)
{
stream.Position = 0;
string s = new StreamReader(stream).ReadToEnd();
TraceHelper.AddMessage(String.Format("Exception in deserializing RequestRecord: {0}; record: {1}", ex.Message, s));
return(null);
}
}
}
}
}
public void onError(Recognizer recognizer, SpeechError error)
{
string text = error.getErrorDetail();
TraceHelper.AddMessage("onError: " + text);
speechStateDelegate.DynamicInvoke(SpeechHelper.SpeechState.Finished, text);
// trace a bad state
if (recognizer != _recognizer)
{
TraceHelper.AddMessage("recognizer doesn't match");
}
_recognizer.cancel();
_recognizer = null;
_speechKit.release();
_speechKit = null;
speechOperationInProgress = false;
}
// deserialize the SerializedBody into Body
public void DeserializeBody()
{
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.Write(this.SerializedBody);
writer.Flush();
Type t = Type.GetType(BodyType);
try
{
stream.Position = 0;
DataContractJsonSerializer ser = new DataContractJsonSerializer(t);
this.Body = ser.ReadObject(stream);
}
catch (Exception ex)
{
stream.Position = 0;
string s = new StreamReader(stream).ReadToEnd();
TraceHelper.AddMessage(String.Format("Exception in deserializing body: {0}; record: {1}", ex.Message, s));
}
}
private static bool SpeechkitInitialize()
{
try
{
_speechKit = SpeechKit.initialize(
NuanceServiceInfo.SpeechKitAppId,
NuanceServiceInfo.SpeechKitServer,
NuanceServiceInfo.SpeechKitPort,
NuanceServiceInfo.SpeechKitSsl,
NuanceServiceInfo.SpeechKitApplicationKey);
}
catch (Exception ex)
{
TraceHelper.AddMessage("Exception in SpeechKitInitialize: " + ex.Message);
return(false);
}
_beep = _speechKit.defineAudioPrompt("beep.wav");
_speechKit.setDefaultRecognizerPrompts(_beep, null, null, null);
_speechKit.connect();
Thread.Sleep(10); // to guarantee the time to load prompt resource
return(true);
}
public static void Stop(SpeechHelper.SpeechToTextCallbackDelegate del)
{
// get the last chunk of speech
int len = mic.GetData(speechBuffer);
// stop listening
mic.Stop();
// remove the mic eventhandler
mic.BufferReady -= MicBufferReady;
initializedBufferReadyEvent = false;
// trace the operation
TraceHelper.AddMessage(String.Format("Final Frame: {0} bytes of speech", len));
// create a properly sized copy of the last buffer
byte[] speechChunk = new byte[len];
Array.Copy(speechBuffer, speechChunk, len);
// add the last speech buffer to the folder
speechBufferList.Add(speechChunk);
// if the encode flag is set, encode the chunk before sending it
if (encode)
{
// do this on a background thread because it is CPU-intensive
ThreadPool.QueueUserWorkItem(delegate
{
// create a new mutex object for this frame
AutoResetEvent bufferMutex = new AutoResetEvent(false);
bufferMutexList.Add(bufferMutex);
// encode the frame
TraceHelper.AddMessage(String.Format("Final Frame: About to encode speech"));
byte[] encodedBuf = EncodeSpeech(speechChunk, speechChunk.Length);
TraceHelper.AddMessage(String.Format("Final Frame: Encoded down to {0} bytes", encodedBuf.Length));
// wait until the previous frame has been sent
int frameIndex = bufferMutexList.Count - 1;
if (frameIndex > 0)
{
bufferMutexList[frameIndex - 1].WaitOne();
}
// send the last frame and retrieve the response
TraceHelper.AddMessage(String.Format("Sending Final Frame: {0} bytes", encodedBuf.Length));
NetworkHelper.EndSpeech(encodedBuf, encodedBuf.Length, del, new NetworkDelegate(NetworkCallback));
// repeat the sentence back to the user
PlaybackSpeech();
});
}
else
{
// send the operation immediately
TraceHelper.AddMessage(String.Format("Sending Final Frame: {0} bytes", speechChunk.Length));
NetworkHelper.EndSpeech(speechChunk, speechChunk.Length, del, new NetworkDelegate(NetworkCallback));
// play back the speech immediately
PlaybackSpeech();
}
}
private static void MicBufferReady(object sender, EventArgs e)
{
// get the data from the mic
int len = mic.GetData(speechBuffer);
numBytes += len;
// make a copy of the frame index and then increment it
int frameIndex = frameCounter++;
// trace the operation
TraceHelper.AddMessage(String.Format("Frame {0}: {1} bytes of speech", frameIndex, len));
// create a properly sized copy of the speech buffer
byte[] speechChunk = new byte[len];
Array.Copy(speechBuffer, speechChunk, len);
// add the chunk to the buffer folder
speechBufferList.Add(speechChunk);
// send the chunk to the service
try
{
// if the encode flag is set, encode the chunk before sending it
if (encode)
{
// do this on a background thread because it is CPU-intensive
ThreadPool.QueueUserWorkItem(delegate
{
// create a new mutex object for this frame
AutoResetEvent bufferMutex = new AutoResetEvent(false);
bufferMutexList.Add(bufferMutex);
// encode the frame
TraceHelper.AddMessage(String.Format("Frame {0}: About to encode speech", frameIndex));
byte[] encodedBuf = EncodeSpeech(speechChunk, speechChunk.Length);
TraceHelper.AddMessage(String.Format("Frame {0}: Encoded down to {1} bytes", frameIndex, encodedBuf.Length));
// wait until the previous frame has been sent
if (frameIndex > 0)
{
bufferMutexList[frameIndex - 1].WaitOne();
}
// send the frame
TraceHelper.AddMessage(String.Format("Sending Frame {0}: {1} bytes", frameIndex, encodedBuf.Length));
NetworkHelper.SendSpeech(encodedBuf, encodedBuf.Length, null, new NetworkDelegate(NetworkCallback));
// set the current frame's mutex
bufferMutex.Set();
});
}
else
{
// just send the frame
TraceHelper.AddMessage(String.Format("Sending Frame {0}: {1} bytes", frameIndex, speechChunk.Length));
NetworkHelper.SendSpeech(speechChunk, speechChunk.Length, null, new NetworkDelegate(NetworkCallback));
}
}
catch (Exception ex)
{
// stop listening
mic.Stop();
// remove the mic eventhandler
mic.BufferReady -= MicBufferReady;
initializedBufferReadyEvent = false;
// trace the exception
TraceHelper.AddMessage(String.Format("Mic buffer ready: ex: {0}", ex.Message));
speechOperationInProgress = false;
return;
}
#if DEBUG
// signal the caller that the chunk has been sent
speechStateDelegate.DynamicInvoke(SpeechHelper.SpeechState.Listening, numBytes.ToString());
#endif
}
/// <summary>
/// This function prepares the request queue for a "Connect with Existing Account" operation
/// If the queue only contains default items (because the user hasn't made any changes), remove the
/// default objects so that we don't create duplicates on the server
///
/// Otherwise, change the names of all the "local" folders to include " (Phone)" so the user can
/// distinguish these folders from the ones that they already have in their existing account
/// Also, remove any operations that have to do with the ClientSettings folder so that we don't have a duplicate
/// </summary>
public static void PrepareUserQueueForAccountConnect()
{
bool deleteQueue = true;
string queueName = RequestQueue.UserQueue;
var requests = GetAllRequestRecords(queueName);
if (requests != null)
{
foreach (var r in requests)
{
if (r.IsDefaultObject == false)
{
deleteQueue = false;
break;
}
}
}
if (deleteQueue)
{
DeleteQueue(queueName);
return;
}
// append (Phone) to all user folders
foreach (var req in requests)
{
if (req.BodyTypeName == typeof(Folder).Name && req.ReqType == RequestRecord.RequestType.Insert)
{
req.DeserializeBody();
var folder = req.Body as Folder;
if (folder != null)
{
folder.Name += " (Phone)";
req.SerializeBody();
}
}
}
DataContractJsonSerializer dc = new DataContractJsonSerializer(requests.GetType());
using (IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication())
{
lock (fileLocks[queueName])
{
// try block because the using block below will throw if the file doesn't exist
try
{
// if the file opens, read the contents
using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(QueueFilename(queueName), FileMode.Truncate, file))
{
try
{
dc.WriteObject(stream, requests);
}
catch (Exception ex)
{
TraceHelper.AddMessage("PrepareQueueForAccountConnect: Error rewriting request queue file; ex: " + ex.Message);
return;
}
}
}
catch (Exception ex)
{
// could not open the isolated storage file
TraceHelper.AddMessage("PrepareQueueForAccountConnect: Error opening request queue file; ex: " + ex.Message);
return;
}
}
}
}
private static void SendData(byte[] buffer, int len, EventHandler <SocketAsyncEventArgs> eh, Delegate netOpInProgressDel)
{
// a request must be in progress
if (isRequestInProgress == false)
{
return;
}
SocketAsyncEventArgs socketSendEventArg = new SocketAsyncEventArgs();
socketSendEventArg.RemoteEndPoint = endPoint;
if (eh != null)
{
socketSendEventArg.Completed += eh;
}
byte[] sendbuf = null;
// if the buffer is null, it means that we need to send the terminating chunk
if (buffer == null)
{
sendbuf = Encoding.UTF8.GetBytes("0\r\n\r\n");
}
else
{
// if the length was passed in as zero, compute it from the buffer length
if (len == 0)
{
len = buffer.Length;
}
// if the length is positive (it'll never be zero), we need to prefix the
// length (expressed in hex) to the buffer. A length of -1 signals to send
// the buffer as-is (this is for sending the headers, which need no length)
if (len > -1)
{
sendbuf = CreateBuffer(buffer, len);
}
else
{
sendbuf = buffer;
}
}
// send the buffer
try
{
// set the buffer and send the chunk asynchronously
socketSendEventArg.SetBuffer(sendbuf, 0, sendbuf.Length);
bool ret = socket.SendAsync(socketSendEventArg);
if (ret == false)
{
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
}
catch (Exception ex)
{
// trace network error
TraceHelper.AddMessage("SendData: ex: " + ex.Message);
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
}
private static void ProcessNetworkResponse(Delegate del, Delegate netOpInProgressDel)
{
if (isRequestInProgress == false)
{
return;
}
SocketAsyncEventArgs socketReceiveEventArg = new SocketAsyncEventArgs();
socketReceiveEventArg.RemoteEndPoint = endPoint;
socketReceiveEventArg.Completed += new EventHandler <SocketAsyncEventArgs>(delegate(object o, SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
return;
}
// response was received
int num = e.BytesTransferred;
if (num > 0)
{
// get the response as a string
string resp = Encoding.UTF8.GetString(e.Buffer, 0, num);
string[] lines = resp.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
if (lines == null || lines.Length < 2 ||
lines[0] != "HTTP/1.1 200 OK")
{
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
// signal that a network operation is done and successful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Success);
// discover the content type (default to json)
string contentType = "application/json";
foreach (var line in lines)
{
if (line.StartsWith("Content-Type:"))
{
string compositeContentType = line.Split(':')[1];
contentType = compositeContentType.Split(';')[0].Trim();
break;
}
}
// get a stream over the last component of the network response
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(lines[lines.Length - 1]));
// deserialize the response string
HttpMessageBodyWrapper <string> body =
(HttpMessageBodyWrapper <string>)HttpWebResponseWrapper <string> .DeserializeResponseBody(
stream, contentType, typeof(HttpMessageBodyWrapper <string>));
// signal that a network operation is done and successful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Success);
// reset the request in progress flag
isRequestInProgress = false;
// * leave the socket open for a potential next transaction *
// CleanupSocket();
// invoke the delegate passed in with the actual response text to return to the caller
del.DynamicInvoke(body == null ? "" : body.Value);
}
else
{
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
});
// set the receive buffer
byte[] buffer = new byte[32768];
socketReceiveEventArg.SetBuffer(buffer, 0, buffer.Length);
// receive the response
try
{
bool ret = socket.ReceiveAsync(socketReceiveEventArg);
if (ret == false)
{
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
}
catch (Exception ex)
{
// trace network error
TraceHelper.AddMessage("ProcessNetworkResponse: ex: " + ex.Message);
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
}
private static void InvokeNetworkRequest(Delegate del, Delegate netOpInProgressDel)
{
// this code is non-reentrant
if (isRequestInProgress == true)
{
return;
}
// set the request in progress flag
isRequestInProgress = true;
// signal that a network operation is starting
netOpInProgressDel.DynamicInvoke(true, OperationStatus.Started);
// get a Uri for the service - this will be used to decode the host / port
Uri uri = new Uri(SpeechUrl);
// create the socket
if (socket == null)
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
if (uri.Host == "localhost")
{
endPoint = new IPEndPoint(IPAddress.Loopback, uri.Port);
}
else
{
endPoint = new DnsEndPoint(uri.Host, uri.Port, AddressFamily.InterNetwork);
}
}
SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();
socketEventArg.RemoteEndPoint = endPoint;
// set the connect completion delegate
socketEventArg.Completed += new EventHandler <SocketAsyncEventArgs>(delegate(object o, SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
return;
}
// get the current network interface info
NetworkInterfaceInfo netInterfaceInfo = socket.GetCurrentNetworkInterface();
// invoke the completion delegate with the network type info
del.DynamicInvoke(netInterfaceInfo);
});
// if the socket isn't connected, connect now
if (socket.Connected == false)
{
// connect to the service
try
{
bool ret = socket.ConnectAsync(socketEventArg);
if (ret == false)
{
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
}
catch (Exception ex)
{
// trace network error
TraceHelper.AddMessage("InvokeNetworkRequest: ex: " + ex.Message);
// signal that a network operation is done and unsuccessful
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
// clean up the socket
CleanupSocket();
}
}
else
{
// socket already connected
// get the current network interface info
NetworkInterfaceInfo netInterfaceInfo = socket.GetCurrentNetworkInterface();
// invoke the completion delegate with the network type info
del.DynamicInvoke(netInterfaceInfo);
}
}
// Common code to process the response from any web service call. This is invoked from the callback
// method for the web service, and passed a Type for deserializing the response body.
// This method will also invoke the delegate with the result of the Web Service call
private static void ProcessResponse <T>(IAsyncResult result)
{
WebServiceState state = result.AsyncState as WebServiceState;
if (state == null)
{
return;
}
// get the network operation status delegate
Delegate netOpInProgressDel = state.NetworkOperationInProgressDelegate as Delegate;
// get the web response and make sure it's not null (failed)
HttpWebResponseWrapper <T> resp = GetWebResponse <T>(result);
if (resp == null)
{
// signal that the network operation completed unsuccessfully
if (netOpInProgressDel != null)
{
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
}
return;
}
else
{
OperationStatus status = AsOperationStatus(resp.StatusCode);
if (resp.StatusCode == HttpStatusCode.Unauthorized)
{ // using this status code to indicate cookie has expired or is invalid
if (authCookie != null)
{ // remove cookie and retry with credentials
status = OperationStatus.Retry;
authCookie = null;
}
}
if (resp.StatusCode == HttpStatusCode.Forbidden)
{ // remove cookie and force authentication on next request
authCookie = null;
}
if (netOpInProgressDel != null)
{ // signal the network operation completed and whether it completed successfully
netOpInProgressDel.DynamicInvoke(false, status);
if (status == OperationStatus.Retry)
{ // delegate will retry, exit now
return;
}
}
}
// get the method-specific delegate
Delegate del = state.Delegate as Delegate;
if (del == null)
{
return; // if no delegate was passed, the results can't be processed
}
// invoke the delegate with the response body
try
{
T resultObject = resp.GetBody();
del.DynamicInvoke(resultObject);
}
catch (Exception ex)
{
TraceHelper.AddMessage("ProcessResponse: exception from GetBody or DynamicInvoke; ex: " + ex.Message);
del.DynamicInvoke(null);
}
}
// Common code for invoking all the web service calls.
// GET requests will be served directly from this method,
// POST/PUT/DELETE requests are served from the InvokeWebServiceRequest_Inner method (which is an async callback)
private static void InvokeWebServiceRequest(User user, string url, string verb, object obj, Delegate del, Delegate netOpInProgressDel, AsyncCallback callback)
{
// this code is non-reentrant
if (isRequestInProgress == true)
{
return;
}
// signal that a network operation is starting
if (netOpInProgressDel != null)
{
netOpInProgressDel.DynamicInvoke(true, OperationStatus.Started);
}
Uri uri = null;
if (Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out uri) == false ||
uri.Scheme != "http" && uri.Scheme != "https")
{
TraceHelper.AddMessage("InvokeWebServiceRequest: bad URL: " + url);
return;
}
#if IOS
request = (HttpWebRequest)WebRequest.Create(uri);
request.UserAgent = UserAgents.IOSPhone;
#else
request = WebRequest.CreateHttp(url);
request.UserAgent = UserAgents.WinPhone;
#endif
request.Accept = "application/json";
request.Method = verb == null ? "GET" : verb;
if (authCookie != null)
{ // send auth cookie
request.Headers[authRequestHeader] = authCookie;
}
else if (user != null)
{ // send credentials in authorization header
string credentials = string.Format("{0}:{1}", user.Name, user.Password);
string encodedCreds = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(credentials));
request.Headers[authorizationHeader] = string.Format("Basic {0}", encodedCreds);
}
// set the session ID header
var sessionToken = TraceHelper.SessionToken;
if (sessionToken != null)
{
request.Headers[HttpApplicationHeaders.Session] = sessionToken;
}
// if this is a GET request, we can execute from here
if (request.Method == "GET")
{
// execute the web request and get the response
try
{
WebServiceState reqState = new WebServiceState()
{
Delegate = del,
NetworkOperationInProgressDelegate = netOpInProgressDel
};
IAsyncResult result = request.BeginGetResponse(callback, reqState);
if (result != null)
{
isRequestInProgress = true;
}
}
catch (Exception ex)
{
isRequestInProgress = false;
// trace the exception
TraceHelper.AddMessage("Exception in BeginGetResponse: " + ex.Message);
// signal that a network operation is done and unsuccessful
if (netOpInProgressDel != null)
{
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
}
}
}
else
{
// this is a request that contains a body (PUT, POST, DELETE)
// need to nest another async call - this time to get the request stream
try
{
IAsyncResult result = request.BeginGetRequestStream(
new AsyncCallback(InvokeWebServiceRequest_Inner),
new WebInvokeServiceState()
{
Callback = callback,
Delegate = del,
NetworkOperationInProgressDelegate = netOpInProgressDel,
RequestBody = obj
});
if (result != null)
{
isRequestInProgress = true;
}
}
catch (Exception)
{
isRequestInProgress = false;
// signal that a network operation is done and unsuccessful
if (netOpInProgressDel != null)
{
netOpInProgressDel.DynamicInvoke(false, OperationStatus.Failed);
}
}
}
}