private void OnError(Memory <byte> payloadData)
{
var nack = _deserializer.ToError(payloadData);
_taskManager.OnPayloadErrorResult(nack.Id, nack.Message);
OnErrorReceived?.Invoke(nack.Id, nack.Message);
}
protected override void WndProc(ref Message m)
{
if (m.Msg == WM_FOWINC)
{
if (OnInitAdminOP != null)
{
OnInitAdminOP.Invoke(this, new MessageEventArgs(m.LParam.ToString()));
}
}
if (m.Msg == WM_FOERROR)
{
if (OnErrorReceived != null)
{
OnErrorReceived.Invoke(this, new MessageEventArgs(m.LParam.ToString()));
}
}
if (m.Msg == WindowsAPI.WM_COPYDATA)
{
byte[] b = new Byte[Marshal.ReadInt32(m.LParam, IntPtr.Size)];
IntPtr dataPtr = Marshal.ReadIntPtr(m.LParam, IntPtr.Size * 2);
Marshal.Copy(dataPtr, b, 0, b.Length);
string message = System.Text.Encoding.Unicode.GetString(b);
if (OnMessageReceived != null)
{
OnMessageReceived.Invoke(this, new MessageEventArgs(message));
}
}
base.WndProc(ref m);
}
/// <summary>
/// エラー発生時の処理
/// </summary>
/// <param name="Callback">エラー検知用コールバック</param>
public void RegisterOnError(OnErrorReceived Callback)
{
Debug.WriteLine("RegisterOnError() <start>");
this.OnErrorCallback = Callback;
Debug.WriteLine("RegisterOnError() <end>");
}
private void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
{
if (e.Data != null)
{
Console.WriteLine(e.Data);
OnErrorReceived?.Invoke(this, new StringEventArgs(e.Data));
}
else
{
countdownEvent.AddCount();
}
}
/// <summary>
/// Opens the Pylon library to Camera Index.
/// </summary>
public void Open()
{
try {
ImageProvider.Open(Index);
} catch (Exception ex) {
log.Fatal("ERROR while opening device with Index " + Index);
log.Fatal("Device Info: " + FullName);
log.Fatal("Exception: " + ex.ToString());
OnErrorReceived?.Invoke(this, ex);
}
}
/// <summary>
/// Starts continous grabbing of ImageProvider.
/// </summary>
public void Start()
{
try {
// Save range set to 0, but the imageProvider is still working. We Stop it.
if (HasStarted && SaveRange <= 0)
{
Stop();
return;
}
// Disable the camera on Save range zero.
if (HasStarted || SaveRange <= 0)
{
return;
}
ImageProvider.ContinuousShot();
/*using (var p = Process.GetCurrentProcess ()) {
*
* Console.Clear ();
*
* int pS = 1;
*
*
* foreach (ProcessThread t in p.Threads) {
* if (t.PriorityLevel == ThreadPriorityLevel.Highest) {
* //t.PriorityLevel = ThreadPriorityLevel.TimeCritical;
*
* t.IdealProcessor = pS;
*
* pS++;
*
* if (pS >= 8)
* pS = 1;
* }
* //Console.WriteLine (t.CurrentPriority + " - " + t.Id + " - " + t.PriorityBoostEnabled + " - " + t.PriorityLevel);
* }
*
* }*/
HasStarted = true;
} catch (Exception ex) {
log.Fatal("ERROR while starting continuous sht on device with Index " + Index);
log.Fatal("Device Info: " + FullName);
log.Fatal("Exception: " + ex.ToString());
OnErrorReceived?.Invoke(this, ex);
}
}
public void Error(string?message,
[CallerMemberName] string?previousMethodName = null,
[CallerLineNumber] int callermemberlineNo = 0,
[CallerFilePath] string?calledFilePath = null)
{
if (string.IsNullOrEmpty(message))
{
return;
}
LogMessageReceived?.Invoke(this, new LogMessageEventArgs(LogIdentifier, message, DateTime.Now, LogLevels.Error, previousMethodName, callermemberlineNo, calledFilePath));
OnErrorReceived?.Invoke(this, new EventArgsBase(LogIdentifier, DateTime.Now, message, previousMethodName, callermemberlineNo, calledFilePath));
}
/// <summary>
/// Closes the image provider safely.
/// </summary>
public void Close()
{
try {
ImageProvider.Close();
HasStarted = false;
} catch (Exception ex) {
log.Fatal("ERROR while closing device with Index " + Index);
log.Fatal("Device Info: " + FullName);
log.Fatal("Exception: " + ex.ToString());
OnErrorReceived?.Invoke(this, ex);
}
}
/// <summary>
/// SSE Pushサーバと接続し、メッセージを受信する
/// </summary>
/// <param name="username">Basic認証に使用するユーザ名</param>
/// <param name="password">Basic認証に使用するパスワード</param>
/// <param name="OnErrorCallback">エラーコールバック</param>
/// <returns>受信メッセージ</returns>
public IObservable <string> ReadLines(string username, string password, OnErrorReceived OnErrorCallback)
{
this.OnErrorCallback = OnErrorCallback;
Func <int, TimeSpan> strategy = ExponentialBackoff;
// エラー時の処理
var delay = Observable.Defer(() =>
{
// もしWebResponseが存在する場合はクローズする
if (this.WebResponse != null)
{
this.WebResponse.Close();
}
// サーバから503エラーでヘッダにリトライ値が設定された場合、
// またはSSEメッセージで"retry"値が設定された場合はその値で待つ(1度のみ)
if (this.RetryFlag)
{
// リトライフラグと接続試行回数をリセット
this.RetryFlag = false;
this.attempt = 0;
return(Observable.Empty <string>().Delay(TimeSpan.FromMilliseconds(this.ReconnectionTime)));
}
// それ以外は Exponential Backoff で待つ
else
{
return(Observable.Empty <string>().DelaySubscription(strategy(++attempt)));
}
});
return(Request(username, password)
.Where(IsEventStream)
.SelectMany(webResponse =>
{
stateSubject.OnNext(EventSourceState.OPEN);
// 再接続時間を初期化
this.ReconnectionTime = this.DefaultReconnectionTime;
// 接続施行回数をリセット
this.attempt = 0;
return Read(webResponse);
})
.Catch((Exception e) => NotifyHttpError(e))
.OnErrorResumeNext(delay).Repeat());
}
public int Start()
{
try
{
IPAddress ipAddr = IPAddress.Parse(addr);
IPEndPoint localEndPoint = new IPEndPoint(ipAddr, Convert.ToInt32(port));
socket = new Socket(ipAddr.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
try
{
socket.Connect(localEndPoint);
OnErrorReceived?.Invoke(this, "CONNECTED");
return(0);
}
catch (ArgumentNullException ane)
{
OnErrorReceived?.Invoke(this, ane.Message);
return(-1);
}
catch (SocketException se)
{
OnErrorReceived?.Invoke(this, se.Message);
return(se.ErrorCode);
}
catch (Exception ex)
{
OnErrorReceived?.Invoke(this, ex.Message);
return(-1);
}
}
catch (Exception ex)
{
OnErrorReceived?.Invoke(this, ex.Message);
return(-1);
}
}
public void Send(string str)
{
try
{
//byte[] messageSent = Encoding.UTF8.GetBytes(str);
//byte[] testmsg = Encoding.ASCII.GetBytes("{\"type\": \"ping\", \"value\": \"ping\"}\n");
byte[] jsonUTF8;
var options = new JsonSerializerOptions
{
};
jsonUTF8 = JsonSerializer.SerializeToUtf8Bytes(new PingRequest("ping", "ping"), options);
byte[] end = { Convert.ToByte('\n') };
byte[] testmsg = jsonUTF8.Concat(end).ToArray();
int byteSent = socket.Send(testmsg);
}
catch (SocketException e)
{
OnErrorReceived?.Invoke(this, e.Message);
}
}
public void Listen()
{
StopListening = false;
while (!StopListening)
{
byte[] messageReceived = new byte[1024];
socket.ReceiveTimeout = 2000;
try
{
int byteRecv = socket.Receive(messageReceived);
Console.WriteLine("dlugosc {0}", byteRecv);
OnErrorReceived?.Invoke(this, Encoding.UTF8.GetString(messageReceived, 0, byteRecv));
OnDataReceived?.Invoke(this, Encoding.UTF8.GetString(messageReceived, 0, byteRecv));
}
catch (SocketException e)
{
if (e.ErrorCode != 10060) //timeout
{
OnErrorReceived?.Invoke(this, e.Message);
StopListening = true;
}
}
}
}
/// <summary>
/// Handles the login as a coroutine.
/// </summary>
/// <param name="username">The username that is used.</param>
/// <param name="password">The password that is used.</param>
/// <param name="onResponseReceived">The handler to call on success.</param>
/// <param name="onErrorReceived">The handler to call on error.</param>
/// <returns>An enumerator.</returns>
private IEnumerator _LoginCoroutine(string username, string password, OnResponseReceived onResponseReceived, OnErrorReceived onErrorReceived)
{
var form = new WWWForm();
form.AddField("grant_type", "password");
form.AddField("username", username);
form.AddField("password", password);
using (var req = UnityWebRequest.Post(BaseUrl + "token", form))
{
req.SetRequestHeader("grant_type", "application/x-www-form-urlencoded");
req.downloadHandler = new DownloadHandlerBuffer();
yield return(req.SendWebRequest());
if (req.isNetworkError || req.isHttpError)
{
onErrorReceived(req.error);
}
else
{
onResponseReceived(req.downloadHandler.text);
}
}
}
protected override void OnError(ErrorEventArgs e)
{
base.OnError(e);
OnErrorReceived?.Invoke(this, new ErrorEventArgWrapper(e));
}
private void SendErrorFromException(Exception exception)
{
OnErrorReceived?.Invoke(exception);
}
private void WebSocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
if (StopWebSocket)
{
WebSocketFeed.Close();
return;
}
var json = e.Message;
var response = JsonConfig.DeserializeObject <BaseMessage>(json);
switch (response.Type)
{
case ResponseType.Subscriptions:
break;
case ResponseType.Ticker:
var ticker = JsonConfig.DeserializeObject <Ticker>(json);
OnTickerReceived?.Invoke(sender, new WebfeedEventArgs <Ticker>(ticker));
break;
case ResponseType.Snapshot:
var snapshot = JsonConfig.DeserializeObject <Snapshot>(json);
OnSnapShotReceived?.Invoke(sender, new WebfeedEventArgs <Snapshot>(snapshot));
break;
case ResponseType.L2Update:
var level2 = JsonConfig.DeserializeObject <Level2>(json);
OnLevel2UpdateReceived?.Invoke(sender, new WebfeedEventArgs <Level2>(level2));
break;
case ResponseType.Heartbeat:
var heartbeat = JsonConfig.DeserializeObject <Heartbeat>(json);
OnHeartbeatReceived?.Invoke(sender, new WebfeedEventArgs <Heartbeat>(heartbeat));
break;
case ResponseType.Received:
var received = JsonConfig.DeserializeObject <Received>(json);
OnReceivedReceived?.Invoke(sender, new WebfeedEventArgs <Received>(received));
break;
case ResponseType.Open:
var open = JsonConfig.DeserializeObject <Open>(json);
OnOpenReceived?.Invoke(sender, new WebfeedEventArgs <Open>(open));
break;
case ResponseType.Done:
var done = JsonConfig.DeserializeObject <Done>(json);
OnDoneReceived?.Invoke(sender, new WebfeedEventArgs <Done>(done));
break;
case ResponseType.Match:
var match = JsonConfig.DeserializeObject <Match>(json);
OnMatchReceived?.Invoke(sender, new WebfeedEventArgs <Match>(match));
break;
case ResponseType.LastMatch:
var lastMatch = JsonConfig.DeserializeObject <LastMatch>(json);
OnLastMatchReceived?.Invoke(sender, new WebfeedEventArgs <LastMatch>(lastMatch));
break;
case ResponseType.Error:
var error = JsonConfig.DeserializeObject <Error>(json);
OnErrorReceived?.Invoke(sender, new WebfeedEventArgs <Error>(error));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void InvokeAsyncOnErrorReceived(IrisError error) => OnErrorReceived?.GetInvocationList().ForEach(e => ((ErrorHandler)e).BeginInvoke(error, EndAsyncEventForErrorHandler, EventArgs.Empty));
/// <summary>
/// Handles the updating of a profile as a coroutine.
/// </summary>
/// <param name="id">The profile's id</param>
/// <param name="preferenceTerms">The new and updated preference terms.</param>
/// <param name="onResponseReceived">The handler to call on success.</param>
/// <param name="onErrorReceived">The handler to call on error.</param>
/// <returns>An enumerator.</returns>
private IEnumerator _UpdateProfileCoroutine(string id, PreferenceTerms preferenceTerms, OnResponseReceived onResponseReceived, OnErrorReceived onErrorReceived)
{
using (var req = UnityWebRequest.Put(BaseUrl + "api/user-contexts/" + id, JsonConvert.SerializeObject(preferenceTerms)))
{
req.SetRequestHeader("content-type", "application/json");
req.SetRequestHeader("authorization", _loginResponse.Token);
req.downloadHandler = new DownloadHandlerBuffer();
yield return(req.SendWebRequest());
if (req.isNetworkError || req.isHttpError)
{
onErrorReceived(req.error);
}
else
{
onResponseReceived(req.downloadHandler.text);
}
}
}
void Conexion_ErrorReceived(object sender, SerialErrorReceivedEventArgs ex)
{
OnErrorReceived?.Invoke(sender as SerialPort, ex);
}