public void Dispose()
{
foreach (var @delegate in OnMessageHandler?.GetInvocationList() ?? new Delegate[] {})
{
OnMessageHandler -= @delegate as MessageEventHandler;
}
}
private void ParsePacket(int start, int end)
{
if (buffer[start] != 0x55 && buffer[start + 1] != 0xFF)
{
RaiseError(new Exception("Illegal start for packet! Expected 0x55, 0xFF and got " + printByte(buffer[start]) + ", " + printByte(buffer[start + 1]) + "!"));
return;
}
if (buffer[end - 2] != 0x55 && buffer[end - 1] != 0x00)
{
RaiseError(new Exception("Illegal end for packet! Expected 0x55, 0x00 and got " + printByte(buffer[start]) + ", " + printByte(buffer[start + 1]) + "!"));
return;
}
if (end - start < 5)
{
RaiseError(new Exception("Illegal packet size. Expected at least one byte between start and end of packet!"));
return;
}
byte messageType = buffer[start + 2];
OnMessageHandler handler = null;
if (messageCallbacks.TryGetValue(messageType, out handler))
{
byte[] data = new byte[end - start - 5];
Buffer.BlockCopy(buffer, start + 3, data, 0, end - start - 5);
data = UnescapeStream(data);
handler?.Invoke(this, new MessageEventArgs(data));
}
else
{
RaiseError(new Exception("Unknown message type " + printByte(messageType) + " received on input stream!"));
}
}
public void Look(WebCamTexture texture, OnMessageHandler callback = null)
{
Texture2D snap = new Texture2D(texture.width, texture.height);
snap.SetPixels(texture.GetPixels());
snap.Apply();
Look(snap, callback);
}
public static void WsAddOnMessage(uint objectId, OnMessageHandler callback)
{
if (!JslibInterop.onMessageHandlers.ContainsKey(objectId))
{
JslibInterop.onMessageHandlers[objectId] = null;
}
JslibInterop.onMessageHandlers[objectId] += callback;
}
private void Awake()
{
instance = this;
connection = new Connection(ServerPath, JwtSecret);
messageHandler = new OnMessageHandler(DefaultTag);
connection.MessageHandler = messageHandler;
connection.SubscribeOnOpen(OnOpen);
connection.SubscribeOnClose(OnClose);
}
public static void WsRemoveOnMessage(uint objectId, OnMessageHandler callback)
{
if (!JslibInterop.onMessageHandlers.ContainsKey(objectId))
{
return;
}
JslibInterop.onMessageHandlers[objectId] -= callback;
}
protected void RaiseMessage(string language, string text, OnMessageHandler callback)
{
List <string> lines = new List <string>();
lines.Add(text);
RaiseMessage(new Message()
{
language = language, lines = lines
}, callback);
}
public void Subscribe(string dst, OnMessageHandler handler)
{
var msg = new StompFrame(ClientCommand.SUBSCRIBE);
msg.AddHead("id", dst + "-" + 0);
msg.AddHead("destination", dst);
Enqueue(msg);
subscribes.Add(dst, handler);
}
protected void RaiseError(string text, OnMessageHandler callback)
{
List <string> lines = new List <string>();
lines.Add(text);
RaiseMessage(new Message()
{
error = true, lines = lines
}, callback);
}
protected void RaiseMessage(Message message, OnMessageHandler callback)
{
if (callback != null)
{
callback.Invoke(this, message);
}
else
{
_messages.Enqueue(message);
}
}
private void Start()
{
GlobalObject globalObject = GlobalObject.Instance;
OnMessageHandler handler = globalObject.MessageHandler;
data = new ServerStatus();
EventTag <ServerStatus> e = (EventTag <ServerStatus>)handler.SignTag("status", typeof(ServerStatus));
e.Event += WriteState;
}
public void AddMessageHandler(byte message, OnMessageHandler handler)
{
if (messageCallbacks.ContainsKey(message) == false)
{
messageCallbacks[message] = handler;
}
else
{
messageCallbacks[message] += handler;
}
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
public MessageResponseHelper(IMessageSender messageSender, OnMessageHandler onMessage, OnTimeoutHandler onTimeout)
{
this.MESSAGE_SENDER = messageSender;
this.ON_MESSAGE = onMessage;
this.ON_TIMEOUT = onTimeout;
this.timeout = TimeSpan.FromSeconds(TIMEOUT_5_SEC);
this.matchId = true;
this.sendId = null;
this.METHOD_SEMA = new SemaphoreSlim(1, 1);
this.TIMER_SEMA = new SemaphoreSlim(1, 1);
this.disposed = false;
}
public void Subscribe(string hash, OnMessageHandler messageHandler = null, OnSubscribedHandler subscribedHandler = null, OnMessageHandler deleteHandler = null)
{
Contract.Requires <ArgumentNullException>(hash != null);
Contract.Requires <ArgumentException>(hash.Trim().Length > 0);
Contract.Requires <ArgumentException>(Constants.STREAM_HASH_FORMAT.IsMatch(hash), Messages.INVALID_STREAM_HASH);
if (!_subscriptions.Contains(hash))
{
_subscriptions.Add(hash);
}
if (messageHandler != null)
{
if (_messageHandlers.ContainsKey(hash))
{
_messageHandlers[hash] = messageHandler;
}
else
{
_messageHandlers.Add(hash, messageHandler);
}
}
if (subscribedHandler != null)
{
if (_subscribedHandlers.ContainsKey(hash))
{
_subscribedHandlers[hash] = subscribedHandler;
}
else
{
_subscribedHandlers.Add(hash, subscribedHandler);
}
}
if (deleteHandler != null)
{
if (_deleteHandlers.ContainsKey(hash))
{
_deleteHandlers[hash] = deleteHandler;
}
else
{
_deleteHandlers.Add(hash, deleteHandler);
}
}
Trace.TraceInformation("Subscribing to stream: " + hash);
var message = new { action = "subscribe", hash = hash };
_connection.Send(JsonConvert.SerializeObject(message));
}
public void OnBookMessage(L2PackageDto l2Book, BookType bookType)
{
if (l2Book.Type != L2PackageType.SNAPSHOT_FULL_REFRESH)
{
return;
}
AlgoDictionary[bookType] = l2Book;
OnMessageHandler bookHandler = bookType == BookType.QUOTE ? QuoteMessageHandler :
bookType == BookType.SOURCE ? SourceMessageHandler :
bookType == BookType.TARGET ? TargetMessageHandler : HedgeMessageHandler;
bookHandler?.Invoke(this);
}
public void On(string ev, OnMessageHandler messageHandler)
{
if (messageHandlers.ContainsKey(ev))
{
messageHandlers[ev].Add(messageHandler);
}
else
{
messageHandlers.Add(ev, new List <OnMessageHandler>());
messageHandlers[ev].Add(messageHandler);
}
}
public void RemoveListener(ushort key, OnMessageHandler handler)
{
if (dic.ContainsKey(key))
{
List <OnMessageHandler> listHandler = dic[key];
listHandler.Remove(handler);
if (listHandler.Count == 0)
{
dic.Remove(key);
}
}
}
void Start()
{
globalObject = GlobalObject.Instance;
messageHandler = globalObject.MessageHandler;
EventTag <string> logoutResponse = (EventTag <string>)messageHandler.SignTag("logout/response", typeof(string));
logoutResponse.Event += (sender, message) =>
{
Debug.Log("logout -> " + message.message);
};
Button button = GetComponent <Button>();
button.onClick.AddListener(OnClick);
}
public void Launch()
{
if (HostAddress == null)
{
UpdateStatus(ClientStatus.Disconnected);
return;
}
Task.Run(() =>
{
var ipAddress = IPAddress.Parse(HostAddress.Ip);
var remoteEp = new IPEndPoint(ipAddress, HostAddress.Port);
socket = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(remoteEp);
UpdateStatus(ClientStatus.Connected);
SendMessage("hello");
while (socket != null && socket.Connected)
{
try
{
var bytes = new byte[1024];
var bytesRec = socket.Receive(bytes);
if (bytesRec == 0)
{
break;
}
var message = Encoding.ASCII.GetString(bytes, 0, bytesRec);
while (socket.Available > 0)
{
bytesRec = socket.Receive(bytes);
message += Encoding.ASCII.GetString(bytes, 0, bytesRec);
}
OnMessageHandler?.Invoke(message);
}
catch (Exception ex)
{
break;
}
}
UpdateStatus(ClientStatus.Disconnected);
socket?.Close();
});
}
public void AddListener(ushort key, OnMessageHandler handler)
{
List <OnMessageHandler> listHandler = null;
if (dic.TryGetValue(key, out listHandler))
{
dic[key].Add(handler);
}
else
{
listHandler = new List <OnMessageHandler>();
listHandler.Add(handler);
dic[key] = listHandler;
}
}
public async Task ConnectWebSocket(OnMessageHandler onMessageHandler, OnConnectHandler onConnectHandler = null, OnCloseHandler onCloseHandler = null)
{
await Task.Run(async() =>
{
if (!Guid.TryParse(wsToken, out _))
{
throw new ArgumentException("tokenの値が不正です, UUID形式で入力してください");
}
sakuraioSocket = new ClientWebSocket();
try
{
await sakuraioSocket.ConnectAsync(new Uri("wss://api.sakura.io/ws/v1/" + wsToken), CancellationToken.None);
}
catch (System.Net.WebSockets.WebSocketException)
{
throw new WebSocketException("WebSocketの接続に失敗しました");
}
// 特に指定がなければ呼ばない
onConnectHandler?.Invoke(true);
while (sakuraioSocket.State == WebSocketState.Open)
{
var buff = new ArraySegment <byte>(new byte[MessageBufferSize]);
var ret = await sakuraioSocket.ReceiveAsync(buff, CancellationToken.None);
if (!ret.EndOfMessage)
{
continue;
}
var frameString = (new UTF8Encoding()).GetString(buff.Take(ret.Count).ToArray());
Console.WriteLine(frameString);
var cmsg = DeserializeChannelMessage(frameString);
if (cmsg == null)
{
continue;
}
onMessageHandler(cmsg);
}
onCloseHandler?.Invoke();
});
}
private void Query(Color32[] data, int width, int height, OnMessageHandler callback)
{
Thread thread = new Thread(new ThreadStart(() => {
try
{
Result result = barcodeReader.Decode(data, width, height);
if (result != null)
{
RaiseMessage(result.Text, callback);
}
}
catch (Exception ex)
{
RaiseError(ex.Message, callback);
}
Reset();
}));
thread.Start();
}
private void Start()
{
globalObject = GlobalObject.Instance;
messageHandler = globalObject.MessageHandler;
EventTag <string> loginResponse =
(EventTag <string>)messageHandler.SignTag("login/response", typeof(string));
loginResponse.Event += (sender, message) =>
{
Debug.Log(message.message);
if (message.data != null)
{
Debug.Log("we got something : " + message.data);
}
};
Button button = GetComponent <Button>();
button.onClick.AddListener(OnClick);
}
void Start()
{
globalObject = GlobalObject.Instance;
messageHandler = globalObject.MessageHandler;
EventTag <Me> meResponse = (EventTag <Me>)messageHandler.SignTag("me/response", typeof(Me));
meResponse.Event += (sender, message) =>
{
if (message.message != null)
{
Debug.Log("me -> " + message.message);
}
else
{
Debug.Log("me -> " + JsonConvert.SerializeObject(message.data));
}
};
Button button = GetComponent <Button>();
button.onClick.AddListener(OnClick);
}
public abstract void Look(Texture2D texture, OnMessageHandler callback = null);
public Server(int port, OnMessageHandler handler)
{
this.port = port;
this.onMessageHandler += handler;
}
public void Publish(T message)
{
OnMessageHandler?.Invoke(message);
}
private void QueryForText(byte[] data, OnMessageHandler callback)
{
// register callback support (required for WebClient)
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
AddCertificateChainValidation();
}
// make the web call
using (WebClient client = new WebClient())
{
client.Headers.Add("Ocp-Apim-Subscription-Key", VisionKey);
client.Headers.Add("Content-Type", "application/octet-stream");
client.UploadDataCompleted += (object sender, UploadDataCompletedEventArgs e) =>
{
try
{
if (e.Cancelled)
{
_status = StatusOptions.failed;
RaiseError("web call was cancelled.", callback);
}
else if (e.Error != null)
{
_status = StatusOptions.failed;
RaiseError(e.Error.Message, callback);
}
else
{
string response_string = System.Text.Encoding.Default.GetString(e.Result);
TextResponse response_object = JsonUtility.FromJson <TextResponse>(response_string);
if (response_object.regions != null && response_object.regions.Count > 0)
{
List <string> lines = new List <string>();
response_object.regions.ForEach(region =>
{
region.lines.ForEach(line =>
{
List <string> words = new List <string>();
line.words.ForEach(word =>
{
words.Add(word.text);
});
lines.Add(string.Join(" ", words.ToArray()));
});
});
// translate if requested
if (!string.IsNullOrEmpty(TranslationKey) && !string.IsNullOrEmpty(TranslateTo) && TranslateTo != response_object.language)
{
Promise <string> accessToken_promise = QueryForAccessToken();
accessToken_promise.Done(() =>
{
Promise <string> translation_promise = QueryForTranslation(string.Join(" ", lines.ToArray()), response_object.language, "en");
translation_promise.Done((msg) =>
{
List <string> translated = new List <string>();
translated.Add(msg);
RaiseMessage(new Message()
{
language = "en", lines = translated
}, callback);
});
translation_promise.Fail((msg) =>
{
RaiseError(msg, callback);
});
});
accessToken_promise.Fail((msg) =>
{
RaiseError(msg, callback);
});
}
else
{
RaiseMessage(new Message()
{
language = response_object.language, lines = lines
}, callback);
}
}
}
}
catch (Exception ex)
{
_status = StatusOptions.failed;
RaiseError(ex.Message, callback);
}
Reset();
};
client.UploadDataAsync(new System.Uri("https://" + Region + ".api.cognitive.microsoft.com/vision/v1.0/ocr?language=unk&detectOrientation=false"), data);
}
}
public override void Look(Texture2D texture, OnMessageHandler callback)
{
QueryForText(texture.EncodeToPNG(), callback);
}
public override void Look(Texture2D texture, OnMessageHandler callback)
{
Query(texture.GetPixels32(), texture.width, texture.height, callback);
}
public void Subscribe(string hash, OnMessageHandler messageHandler = null, OnSubscribedHandler subscribedHandler = null, OnMessageHandler deleteHandler = null)
{
Contract.Requires<ArgumentNullException>(hash != null);
Contract.Requires<ArgumentException>(hash.Trim().Length > 0);
Contract.Requires<ArgumentException>(Constants.STREAM_HASH_FORMAT.IsMatch(hash), Messages.INVALID_STREAM_HASH);
if(!_subscriptions.Contains(hash))
_subscriptions.Add(hash);
if(messageHandler != null)
{
if (_messageHandlers.ContainsKey(hash))
_messageHandlers[hash] = messageHandler;
else
_messageHandlers.Add(hash, messageHandler);
}
if (subscribedHandler != null)
{
if (_subscribedHandlers.ContainsKey(hash))
_subscribedHandlers[hash] = subscribedHandler;
else
_subscribedHandlers.Add(hash, subscribedHandler);
}
if (deleteHandler != null)
{
if (_deleteHandlers.ContainsKey(hash))
_deleteHandlers[hash] = deleteHandler;
else
_deleteHandlers.Add(hash, deleteHandler);
}
Trace.TraceInformation("Subscribing to stream: " + hash);
var message = new { action = "subscribe", hash = hash };
_connection.Send(JsonConvert.SerializeObject(message));
}
