public ConfigThreadState(BucketConfig bucketConfig, ConfigChanged configChangedDelegate,
ErrorOccurred errorOccurredDelegate, CancellationToken cancellationToken)
{
_bucketConfig = bucketConfig;
_configChangedDelegate += configChangedDelegate;
_errorOccurredDelegate += errorOccurredDelegate;
_cancellationToken = cancellationToken;
}
private void OnSended(Session session, int bytesSent)
{
try { Sended?.Invoke(this, new SendEventArgs(session.IP, bytesSent)); }
catch (Exception e) { ErrorOccurred?.Invoke(this, new ExceptionEventArgs(e)); }
}
async Task DoRecord()
{
try
{
var frameInterval = TimeSpan.FromSeconds(1.0 / _frameRate);
var frameCount = 0;
Task <IBitmapFrame> task = null;
// Returns false when stopped
bool AddFrame(IBitmapFrame Frame)
{
try
{
_frames.Add(Frame);
++frameCount;
return(true);
}
catch (InvalidOperationException)
{
return(false);
}
}
bool CanContinue()
{
try
{
return(_continueCapturing.WaitOne());
}
catch (ObjectDisposedException)
{
return(false);
}
}
while (CanContinue() && !_frames.IsAddingCompleted)
{
if (_frames.Count > MaxFrameCount)
{
throw new Exception("System can't keep up with the Recording. Frames are not being written. Try a lower Frame Rate or another Codec.");
}
var timestamp = DateTime.Now;
if (task != null)
{
var frame = await task;
if (!AddFrame(frame))
{
return;
}
var requiredFrames = _sw.Elapsed.TotalSeconds * _frameRate;
var diff = requiredFrames - frameCount;
for (var i = 0; i < diff; ++i)
{
if (!AddFrame(RepeatFrame.Instance))
{
return;
}
}
}
task = Task.Factory.StartNew(() => _imageProvider.Capture());
var timeTillNextFrame = timestamp + frameInterval - DateTime.Now;
if (timeTillNextFrame > TimeSpan.Zero)
{
Thread.Sleep(timeTillNextFrame);
}
}
}
catch (Exception e)
{
lock (_syncLock)
{
if (!_disposed)
{
ErrorOccurred?.Invoke(e);
Dispose(false, true);
}
}
}
}
public static void SendIni(FileInfo info)
{
if (!WaitingForIniInject)
{
IniTask = Task.Run(() =>
{
bool attemptInject()
{
Device.AbortPipe(1);
Device.AbortPipe(0x81);
DirectoryInfo root = info.Directory;
MemloaderIniData iniData = new MemloaderIniData(info);
Task <bool> task;
foreach (LoadData currData in iniData.LoadData)
{
task = DeviceWrapper.WriteAsync("RECV".ToBytes(), 2000);
task.Wait();
if (!task.Result)
{
return(false);
}
FileInfo file = root.GetFile(currData.SourceFile);
IEnumerable <byte> data = File.ReadAllBytes(file.FullName);
int skip = (int)currData.Skip;
int dataLength = data.Count() - skip;
if (currData.Count > 0)
{
dataLength = Math.Min(dataLength, (int)currData.Count);
}
IEnumerable <byte> address = currData.Dest.ToBytes(4).Reverse();
IEnumerable <byte> size = dataLength.ToBytes(4).Reverse();
byte[] bytesToSend = address.Concat(size).ToArray();
task = DeviceWrapper.WriteAsync(bytesToSend, 2000);
task.Wait();
if (!task.Result)
{
return(false);
}
task = DeviceWrapper.WriteAsync(data.Skip(skip).Take(dataLength).ToArray(), 2000);
task.Wait();
if (!task.Result)
{
return(false);
}
}
foreach (BootData currData in iniData.BootData)
{
Device.WritePipe(1, "BOOT".ToBytes(), 4, out int lengthTransfered, IntPtr.Zero);
if (lengthTransfered != 4)
{
return(false);
}
IEnumerable <byte> pc = currData.PC.ToBytes(4).Reverse();
task = DeviceWrapper.WriteAsync(pc.ToArray(), 2000);
task.Wait();
if (!task.Result)
{
return(false);
}
}
return(true);
};
WaitForReady();
while (!attemptInject())
{
WaitForReady();
}
})
.ContinueWith(t => {
IniTask = null; // task is complete, discard
IniInjectFinished?.Invoke();
})
.ContinueWith(t => ErrorOccurred?.Invoke(), TaskContinuationOptions.OnlyOnFaulted); // catch exceptions and inform delegate
}
}
/// <summary>
/// Invokes "ErrorOccurred" to other application's modules.
/// </summary>
/// <param name="errorMessage">Message of a thrown error.</param>
private void ErrorHandler(string errorMessage, [CallerFilePath] string file = "", [CallerMemberName] string func = "", [CallerLineNumber] int line = 0)
{
global::Tizen.Log.Error(Program.LogTag, errorMessage, file, func, line);
ErrorOccurred?.Invoke(this, errorMessage);
}
private void InterstitialAd_ErrorOccurred(object sender, MSAd.AdErrorEventArgs e)
{
ErrorOccurred?.Invoke(this, new AdErrorEventArgs(e.ErrorMessage));
}
private void Listener(TcpClient tcpClient)
{
try
{
using (Stream stream = tcpClient.GetStream())
{
while (true)
{
BinaryReader streamReader = new BinaryReader(stream);
PacketType packetType = (PacketType)streamReader.ReadInt32();
switch (packetType)
{
case PacketType.Registry:
RegistryPacket registryPacket = new RegistryPacket(stream);
registryPacket.Receive();
RegistryNewUser(tcpClient, registryPacket);
break;
case PacketType.Login:
LoginPacket loginPacket = new LoginPacket(stream);
loginPacket.Receive();
if (!LoginUser(tcpClient, loginPacket))
{
return;
}
break;
case PacketType.SimpleMessage:
SimpleMessagePacket simpleMessagePacket = new SimpleMessagePacket(stream);
simpleMessagePacket.Receive();
lock (_connectedUsers)
{
foreach (TcpClient client in _connectedUsers.Values)
{
simpleMessagePacket.Send(client.GetStream());
}
}
break;
case PacketType.Disconnect:
lock (_connectedUsers)
{
var item = _connectedUsers.First(u => u.Value == tcpClient);
_connectedUsers.Remove(item.Key);
}
return;
case PacketType.UserDisconnect:
UserDisconnectPacket userDisconnectPacket = new UserDisconnectPacket(stream);
userDisconnectPacket.Receive();
lock (_connectedUsers)
{
foreach (TcpClient client in _connectedUsers.Values)
{
userDisconnectPacket.Send(client.GetStream());
}
}
lock (_connectedUsers)
{
_connectedUsers.Remove(userDisconnectPacket.UserLogin);
_context.Send(p => ClientDisconnected?.Invoke(this, new DisconnectedEventHandlerArgs(tcpClient, userDisconnectPacket.UserLogin)), null);
}
return;
case PacketType.CreateNewRoom:
lock (_rooms)
{
CreateNewRoomPacket createNewRoomPacket = new CreateNewRoomPacket(stream);
createNewRoomPacket.Receive();
_rooms.Add(createNewRoomPacket.Room.Id, createNewRoomPacket.Room);
lock (_connectedUsers)
{
foreach (var connectedUser in _connectedUsers.Where(cu =>
createNewRoomPacket.Room.Members.Contains(cu.Key)))
{
createNewRoomPacket.Send(connectedUser.Value.GetStream());
}
}
}
break;
case PacketType.CloseRoom:
CloseRoomPacket closeRoomPacket = new CloseRoomPacket(stream);
closeRoomPacket.Receive();
lock (_rooms)
{
Room room;
if (_rooms.TryGetValue(closeRoomPacket.RoomId, out room))
{
lock (_connectedUsers)
{
foreach (TcpClient client in _connectedUsers.Where(u =>
room.Members.Contains(u.Key)).Select(u => u.Value))
{
new RemoveUserFromRoomPacket(client.GetStream(), closeRoomPacket.RoomId, closeRoomPacket.User).Send();
}
}
}
}
break;
case PacketType.UpdateUser:
UpdateUserPacket updateUserPacket = new UpdateUserPacket(stream);
updateUserPacket.Receive();
UserManager.Instance.Update(updateUserPacket.Login, updateUserPacket.UserInfoWithPrivateInfo);
break;
}
}
}
}
catch (Exception ex)
{
_context.Post(p => ErrorOccurred?.Invoke(this, new ErrorOccurredEventHandlerArgs(ex.Message, ErrorType.ServerListener)), null);
}
}
private void HandleExceptionOccured(Exception exception)
{
ErrorOccurred?.Invoke(this, exception);
}
protected void OnOperationErrorOccurred(object sender, OperationEventArgs e)
{
ErrorOccurred?.Invoke(sender, e);
}
protected virtual void OnErrorOccurred(Tuple <string, Exception> e)
{
ErrorOccurred?.Invoke(this, e);
}
private void Handle_ErrorOccurred(object sender, ClientErrorEventArgs e)
{
_logger?.LogError(e.Exception, $"ErrorOccurred: {e.Exception.ToString()}");
ErrorOccurred?.Invoke(sender, e);
}
private void RaiseError(Exception exception) => ErrorOccurred?.Invoke(exception);
private void HandleErrorOccurred(ErrorOccurred message)
{
Context.Stop(Self);
Context.Parent.Tell(message);
}
protected void OnErrorOccurred(PlayerErrorOccurredEventArgs e)
{
ErrorOccurred?.Invoke(this, e);
}
private void OnErrorOccured(string errorMessage)
{
ErrorOccurred?.Invoke(this, new ErrorOccurredEventArgs(errorMessage));
}
protected virtual void OnConnectionErrorReceived(ErrorEventArgs args)
{
_logger.LogError(args.Exception, "Socket connection");
ErrorOccurred?.Invoke(this, new BitmextErrorEventArgs(args.Exception));
}
protected virtual void NotifyOfError(Exception e)
{
Logging.Error(e);
ErrorOccurred?.Invoke(e);
}
private void OnErrorOccurred(FlowSourceManager flowSourceManager, FlowExecutionException e)
{
ErrorOccurred?.Invoke(flowSourceManager, e);
}
/// <summary>
/// Handles "ErrorOccurred" of the IMediaDatabaseService object.
/// Invokes "ErrorOccurred" event.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="errorMessage">Error message.</param>
private void ErrorOccurredEventHandler(object sender, string errorMessage)
{
ErrorOccurred?.Invoke(this, errorMessage);
}
/// <summary>
/// Raises <see cref="ErrorOccurred"/> event.
/// </summary>
/// <param name="exception">An exception that represents error occurred.</param>
protected void OnError(Exception exception)
{
ErrorOccurred?.Invoke(this, new ErrorOccurredEventArgs(exception));
}
void OnErrorOccurred(IErrorInfo errorInfo)
{
ErrorOccurred?.Invoke(errorInfo);
}
private void OnErrorOccurred(string fileName, int id, string error)
{
ErrorOccurred?.Invoke(fileName, id, error);
}
/// <summary>
/// Notifies user about the error.
/// Invokes "ErrorOccurred" to other application's modules.
/// </summary>
/// <param name="errorMessage">Message of a thrown error.</param>
private void ErrorHandler(string errorMessage)
{
ErrorOccurred?.Invoke(this, errorMessage);
}
/// <summary>Hanterar error event</summary>
/// <param name="sender">Avsändare</param>
/// <param name="args">Errorargument</param>
private void workerClassOnErrorOccurred(object sender, ErrorEvent args)
{
ErrorOccurred?.Invoke(this, args);
}
async Task DoRecord()
{
try
{
var frameInterval = TimeSpan.FromSeconds(1.0 / _frameRate);
var frameCount = 0;
Task <bool> task = null;
// Returns false when stopped
bool AddFrame(IBitmapFrame Frame)
{
try
{
_frames.Add(Frame);
++frameCount;
return(true);
}
catch (InvalidOperationException)
{
return(false);
}
}
bool CanContinue()
{
try
{
return(_continueCapturing.WaitOne());
}
catch (ObjectDisposedException)
{
return(false);
}
}
while (CanContinue() && !_frames.IsAddingCompleted)
{
if (!_congestion && _frames.Count > _congestionFrameCount)
{
_congestion = true;
WriteLog("Congestion: ON");
Console.WriteLine("Congestion: ON");
}
else if (_congestion && _frames.Count < _congestionFrameCount / 2)
{
_congestion = false;
WriteLog("Congestion: OFF");
Console.WriteLine("Congestion: OFF");
}
if (_frames.Count > _maxFrameCount)
{
WriteLog("Max-Frame reached - Memory issue might arise.");
if (_exitOnMaxFrameReach)
{
throw new Exception(@"System can't keep up with the Recording. Frames are not being written. Retry again or try with a smaller region, lower Frame Rate or another Codec.");
}
}
var timestamp = DateTime.Now;
if (task != null)
{
// If false, stop recording
if (!await task)
{
return;
}
if (!_congestion)
{
var requiredFrames = _sw.Elapsed.TotalSeconds * _frameRate;
var diff = requiredFrames - frameCount;
for (var i = 0; i < diff; ++i)
{
if (!AddFrame(RepeatFrame.Instance))
{
return;
}
}
}
}
task = Task.Factory.StartNew(() =>
{
var frame = _imageProvider.Capture();
return(AddFrame(frame));
});
var timeTillNextFrame = timestamp + frameInterval - DateTime.Now;
if (timeTillNextFrame > TimeSpan.Zero)
{
Thread.Sleep(timeTillNextFrame);
}
}
}
catch (Exception e)
{
WriteLog("DoRecord() - " + e.Message + " - " + e.StackTrace);
lock (_syncLock)
{
if (!_disposed)
{
ErrorOccurred?.Invoke(e);
Dispose(false, true);
}
}
}
}
/// <summary>
/// Etablerar händelse vid fel.
/// </summary>
/// <param name="evnt">ErrorEvent</param>
private void onErrorOccurred(ErrorEvent evnt)
{
ErrorOccurred?.Invoke(this, evnt);
}
/// <summary>Raise the ErrorOccurred event.</summary>
/// <param name="e">The error event args.</param>
public void RaiseErrorOccurred(SettingsErrorEventArgs e)
{
ErrorOccurred?.Invoke(this, e);
}
void ReportError(string error)
{
ErrorOccurred?.Invoke(this, error);
}
async Task DoRecord()
{
try
{
var frameInterval = TimeSpan.FromSeconds(1.0 / _frameRate);
var frameCount = 0;
// Returns false when stopped
bool AddFrame(IBitmapFrame Frame)
{
try
{
_videoWriter.WriteFrame(Frame);
++frameCount;
return(true);
}
catch (InvalidOperationException)
{
return(false);
}
//catch (Exception)
//{
// return false;
//}
}
bool CanContinue()
{
try
{
return(_continueCapturing.WaitOne());
}
catch (ObjectDisposedException)
{
return(false);
}
}
while (CanContinue() && !_cancellationToken.IsCancellationRequested)
{
var timestamp = _sw.Elapsed;
if (_task != null)
{
// If false, stop recording
if (!await _task)
{
return;
}
var requiredFrames = _sw.Elapsed.TotalSeconds * _frameRate;
var diff = requiredFrames - frameCount;
// Write atmost 1 duplicate frame
if (diff >= 1)
{
if (!AddFrame(RepeatFrame.Instance))
{
return;
}
}
}
_task = Task.Factory.StartNew(() =>
{
var editableFrame = _imageProvider.Capture();
if (_cancellationToken.IsCancellationRequested)
{
return(false);
}
var frame = editableFrame.GenerateFrame(timestamp);
if (_cancellationToken.IsCancellationRequested)
{
return(false);
}
return(AddFrame(frame));
});
var timeTillNextFrame = timestamp + frameInterval - _sw.Elapsed;
if (timeTillNextFrame > TimeSpan.Zero)
{
Thread.Sleep(timeTillNextFrame);
}
}
}
catch (Exception e)
{
lock (_syncLock)
{
if (!_disposed)
{
ErrorOccurred?.Invoke(e);
Dispose(false);
}
}
}
}
public void SendError(string message)
{
ErrorOccurred?.Invoke(this, new ErrorEventArgs(message));
}
private void OnReceived(Session session, int bytesRead, byte[] data)
{
try { Received?.Invoke(this, new ReceiveEventArgs(session.IP, bytesRead, data)); }
catch (Exception e) { ErrorOccurred?.Invoke(this, new ExceptionEventArgs(e)); }
}
protected virtual void OnErrorPrompt()
{
ErrorOccurred?.Invoke(this, EventArgs.Empty);
}
