private bool session()
{
List <byte> buffer = new List <byte>();
while (_isALive)
{
try
{
if (_port.BytesToRead != 0)
{
if (tryRead(buffer))
{
if (buffer.IndexOf((byte)'\n') != -1)
{
System.Diagnostics.Trace.WriteLine(Encoding.ASCII.GetString(buffer.ToArray()));
Package package;
if (Package.TryParse(Encoding.ASCII.GetString(buffer.ToArray()), out package))
{
Read.Raise <CardEventArgs>(this, new CardEventArgs(package));
}
buffer.RemoveRange(0, buffer.IndexOf((byte)'\n') + 1);
}
}
}
else
{
Thread.Sleep(50);
}
}
catch (UnauthorizedAccessException)
{
Failed.Raise(this, new LinkEventArgs(String.Format("Hardware error. The device is faulty or not connected ({0})", _port.PortName)));
return(false);
}
catch (Exception e)
{
Failed.Raise(this, new LinkEventArgs(e.Message));
return(false);
}
}
return(true);
}
/// <summary>
/// Invoked when an StreamManagementStanza stanza is being received.
/// </summary>
/// <param name="stanza">The stanza which is being received.</param>
/// <returns>true to intercept the stanza or false to pass the stanza
/// on to the next handler.</returns>
public bool Input(StreamManagementStanza stanza)
{
if (stanza.Data.NamespaceURI == "urn:xmpp:sm:3")
{
// We need to manage:
// "enabled": in response to "enable"
// "a": read answer from a previous request (at each ping)
// "r": request asked by the sver
// "resumed": in response to "resume"
// "failed": in case of pb
switch (stanza.Data.LocalName)
{
case "failed":
im.StreamManagementResumeId = "";
Failed.Raise(this, null); // /!\ This event must be ALWAYS raised before RaiseConnectionStatus !!!
im.RaiseConnectionStatus(false);
break;
case "resumed": // in response to "resume"
Resumed.Raise(this, null); // /!\ This event must be ALWAYS raised before RaiseConnectionStatus !!!
im.RaiseConnectionStatus(true);
break;
case "enabled": // in response to "enable"
// Check if the server accepts resume
string resume = stanza.Data.GetAttribute("resume");
Boolean resumeHandled = (resume == "true") || (resume == "1");
// Get Id used for resume purpose
String resumeId = stanza.Data.GetAttribute("id");
// Has the server accepted Stream management ?
im.StreamManagementEnabled = resumeHandled && !String.IsNullOrEmpty(resumeId);
// Get max delay for the resume
String maxDelay = stanza.Data.GetAttribute("max");
int delay;
if (!int.TryParse(maxDelay, out delay))
{
delay = 86400;
}
// Store id and delay
im.StreamManagementResumeId = resumeId;
im.StreamManagementResumeDelay = delay;
log.LogDebug("[Input] - StreamManagementEnabled:[{0}] - ResumeStreamManagementId:[{1}] - ResumeStreamManagementDelay:[{2}]", im.StreamManagementEnabled, im.StreamManagementResumeId, im.StreamManagementResumeDelay);
break;
case "a": // read answer for a request
// Store last handled stanzas
String h = stanza.Data.GetAttribute("h");
if (!uint.TryParse(h, out stanzasReceivedHandled))
{
stanzasReceivedHandled = 0;
}
im.StreamManagementLastStanzaReceivedAndHandledByServer = stanzasReceivedHandled;
im.StreamManagementLastStanzaDateReceivedAndHandledByServer = DateTime.UtcNow;
//log.LogDebug("[Input] - StreamManagementLastStanzaReceivedAndHandledByClient:[{0}]", im.StreamManagementLastStanzaReceivedAndHandledByClient);
break;
case "r": // answer to the request
im.StreamManagementLastStanzaReceivedAndHandledByClient = im.StreamManagementLastStanzaReceivedByClient;
SendkAcknowledgement(im.StreamManagementLastStanzaReceivedAndHandledByClient);
break;
}
return(true);
}
return(false);
}
void DownloadProcedure()
{
try
{
var endOfStream = false;
var stOffset = Range.Remaining.Start;
var chunkEndOffset = stOffset + 1 * 1024 * 1000 - 1;
var endOffset = UseChunk ? Math.Min(chunkEndOffset, Range.End) : Range.End;
Range.Status = Status = State.SendRequest;
Range.LastTry = DateTime.Now;
request = Info != null?
HttpRequestHelper.CreateHttpRequest(Info, stOffset, endOffset, BeforeSendingRequest) :
HttpRequestHelper.CreateHttpRequest(Url, BeforeSendingRequest, true);
Range.Status = Status = State.GetResponse;
using (var response = Info != null ?
HttpRequestHelper.GetRangedResponse(Info, stOffset, endOffset, request, AfterGettingResponse) :
request.GetResponse() as HttpWebResponse)
{
Range.Status = Status = State.GetResponseStream;
ResponseReceived.Raise(this, new ResponseReceivedEventArgs(response));
while (Wait)
{
Thread.Sleep(100);
}
using (fileStream = FileHelper.CheckFile(Range.FilePath, Range.TotalBytesReceived > 0))
{
using (var str = response.GetResponseStream())
{
var buffer = new byte[10 * 1024];
var bytesRead = 0;
while (true)
{
if (str != null)
{
bytesRead = str.Read(buffer, 0, buffer.Length);
}
if (Info.ContentSize > 0)
{
bytesRead = (int)Math.Min(Range.Size - Range.TotalBytesReceived, bytesRead);
}
if (bytesRead <= 0)
{
endOfStream = true;
break;
}
if (stopFlag)
{
break;
}
if (Info != null && Info.ContentSize > 0 && Range.IsDownloaded)
{
break;
}
Range.Status = Status = State.Downloading;
fileStream.Write(buffer, 0, bytesRead);
Range.TotalBytesReceived += bytesRead;
ProgressChanged.Raise(this, EventArgs.Empty);
}
}
}
}
lock (GlobalLock.Locker)
{
Range.LastTry = DateTime.Now;
if ((!stopFlag && endOfStream && Info.ContentSize < 1) ||
(Info.ContentSize > 0 && Range.IsDownloaded))
{
Range.Status = Status = State.Completed;
Completed.Raise(this, EventArgs.Empty);
}
else if (stopFlag)
{
Range.Status = Status = State.Stopped;
Stopped.Raise(this, EventArgs.Empty);
}
}
}
catch (Exception ex)
{
lock (GlobalLock.Locker)
{
Range.LastTry = DateTime.Now;
if (Info != null && Info.ContentSize > 0 && Range.IsDownloaded)
{
Range.Status = Status = State.Completed;
Completed.Raise(this, EventArgs.Empty);
}
else if (stopFlag)
{
Range.Status = Status = State.Stopped;
Stopped.Raise(this, EventArgs.Empty);
}
else
{
Range.Status = Status = State.Failed;
Failed.Raise(this, new ErrorEventArgs(ex));
}
}
}
finally
{
if (request != null)
{
request.Abort();
}
if (!Range.IsIdle)
{
Range.Status = Status = State.Failed;
}
}
}
