private void MessageClient_OnReceive(byte[] obj)
{
string strMessage = Encoding.UTF8.GetString(obj);
OnReceivedMessage?.Invoke(strMessage);
_receivedQueue.Enqueue(strMessage);
}
private void ReceivedMessageCallback(string receivedMessage)
{
var message = JsonConvert.DeserializeObject <string[]>(receivedMessage)[0];
Debug.WriteLine("RECEIVED MESSAGE: " + message);
OnReceivedMessage?.Invoke(message);
}
public void Init(string ip, bool isBlazor = false)
{
hubConnection = new HubConnectionBuilder()
.WithUrl($"http://{ip}:5000/hubs/chat")
.Build();
hubConnection.Closed += async(error) =>
{
OnConnectionClosed?.Invoke(this, new MessageEventArgs("Connection closed..."));
IsConnected = false;
await Task.Delay(random.Next(0, 5) * 1000);
try
{
await ConnectAsync();
}
catch (Exception ex)
{
// Exception!
}
};
hubConnection.On <string, string>("ReceiveMessage", (user, message) =>
{
var finalMessage = $"{user} says {message}";
OnReceivedMessage?.Invoke(this, new MessageEventArgs(finalMessage));
});
hubConnection.On <string>("EnteredOrLeft", (message) =>
{
OnEnteredOrExited?.Invoke(this, new MessageEventArgs(message));
});
}
private void ReceiveMessage(object stream)
{
latestRequest.done = true;
NetworkStream nStream = stream as NetworkStream;
Message msg;
while (!disposed)
{
if (!latestRequest.done && (DateTime.Now - latestRequest.requestTime).TotalMilliseconds > 3000)
{
requestMp3(latestRequest.mp3Name);
}
msg = mm.ReceiveMessage();
if (msg == null)
{
if (!tcpClient.Connected)
{
break;
}
SendMessage(new Message(MessageCode.test));
continue;
}
ReceivedEventArgs rea = new ReceivedEventArgs(msg);
OnReceivedMessage?.Invoke(this, rea);
if (rea.done)
{
continue;
}
switch (msg.msgCode)
{
case MessageCode.mp3Frame:
int index = (int)msg.data[0];
byte[] frame = msg.data[1] as byte[];
putMp3Frame(index, frame);
break;
case MessageCode.mp3Info:
Mp3Info mp3Info = msg.data[0] as Mp3Info;
if (!latestRequest.done && mp3Info.name == latestRequest.mp3Name)
{
frameList = new byte[mp3Info.totalFrames][];
totalMilliseconds = mp3Info.totalMilliseconds;
sampleRate = mp3Info.sampleRate;
setPosition(0);
latestRequest.done = true;
if (playAfterGetInfo)
{
play();
}
}
break;
}
}
Dispose();
Console.WriteLine("done");
}
public SimpleClientClass(ISignalRInfo connectInfo)
{
_connectInfo = connectInfo;
_thisProgress = new Progress <CustomEventHandler>(items =>
{
OnReceivedMessage?.Invoke(this, items);
});
}
private void OnSubscriberMessageReceived(MqttApplicationMessageReceivedEventArgs obj)
{
index++;
if (IsShowInput)
{
Console.WriteLine($"{obj.ApplicationMessage.Topic}-{Encoding.UTF8.GetString(obj.ApplicationMessage.Payload)}-total received : {index}");
}
OnReceivedMessage?.Invoke(obj);
}
public event EventHandler <MessageEventArgs> OnReceivedMessage; // Evento qu egestiona los mensages recividos
/// <summary>
/// Método para iniciar la conexión al servicio de SignalR
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public async Task InitAsync(string userId)
{
await semaphoreSlim.WaitAsync(); // Se establece el limite de hilos
// Se instancia el cliente HTTP en caso que ya exista el objeto se procede
if (httpClient == null)
{
httpClient = new HttpClient();
}
// Se ejecuta el endpoint "GET" encargado de la negociación al servicio de SignalR
var result = await httpClient.GetStringAsync($"{ Config.NegotiateEndpoint}/{userId}");
// Se deserializa la información obtenida
var info = JsonConvert.DeserializeObject <ConnectionInfo>(result);
// Se instancia un nuevo objeto para crear el Hub de conexión
var connectionBuilder = new HubConnectionBuilder();
// Configuración HUB y del transporte HTTPa conectar en la url especifica
connectionBuilder.WithUrl(info.Url, (obj) => {
obj.AccessTokenProvider = () => Task.Run(() => info.AccessToken);
});
// Se procede a construir el HUB
hub = connectionBuilder.Build();
// Inicialiaza la conexión con el hub
await hub.StartAsync();
// Se obtiene el token de conexión del hub
ConnectionToken = hub.ConnectionId;
// Se estable que la conexión ha sido iniciada
IsConnected = true;
hub.On <object>("ReceiveMessage", (message) => {
// Se obtiene el mensaje
var json = message.ToString();
// Obtengo el mensaje general
var obj = JsonConvert.DeserializeObject <ChatMessage>(json);
// Convertimos al tipo de mensage enviado
var msg = (ChatMessage)JsonConvert.DeserializeObject(json, obj.TypeInfo);
// Lamamos el evento que reportara el nuevo mensaje
OnReceivedMessage?.Invoke(this, new MessageEventArgs(msg));
});
// Se libera el limite de hilos
semaphoreSlim.Release();
}
public void Init(string urlRoot, bool useHttps)
{
random = new Random();
var port = (urlRoot == "localhost" || urlRoot == "10.0.2.2") ?
(useHttps ? ":5001" : ":5000") :
string.Empty;
var url = $"http{(useHttps ? "s" : string.Empty)}://{urlRoot}{port}/hubs/chat";
hubConnection = new HubConnectionBuilder()
.WithUrl(url)
.WithAutomaticReconnect()
.Build();
hubConnection.Closed += async(error) =>
{
OnConnectionClosed?.Invoke(this, new MessageEventArgs("Connection closed...", string.Empty));
IsConnected = false;
await Task.Delay(random.Next(0, 5) * 1000);
try
{
await ConnectAsync();
}
catch (Exception ex)
{
// Exception!
Debug.WriteLine(ex);
}
};
hubConnection.On <string, string>("ReceiveMessage", (user, message) =>
{
OnReceivedMessage?.Invoke(this, new MessageEventArgs(message, user));
});
hubConnection.On <string>("Entered", (user) =>
{
OnEnteredOrExited?.Invoke(this, new MessageEventArgs($"{user} entered.", user));
});
hubConnection.On <string>("Left", (user) =>
{
OnEnteredOrExited?.Invoke(this, new MessageEventArgs($"{user} left.", user));
});
hubConnection.On <string>("EnteredOrLeft", (message) =>
{
OnEnteredOrExited?.Invoke(this, new MessageEventArgs(message, message));
});
}
private void MessageServer_OnReceive(int arg1, byte[] arg2)
{
string strMessage = Encoding.UTF8.GetString(arg2);
if (strMessage.Equals("H"))//this is heartbeat package, leave it.
{
return;
}
OnReceivedMessage?.Invoke(GetClientIpById(arg1), GetClientPortIpById(arg1), arg1, strMessage);
_receivedQueue.Enqueue(new ReceivedMessage {
connectID = arg1, message = strMessage
});
}
public async Task ConnectToHub()
{
_hubConnection = new HubConnectionBuilder()
.WithUrl(_hubUrl)
.Build();
_hubConnection.On <MessageDTO>("ReceiveMessage", message =>
{
OnReceivedMessage?.Invoke(message, new EventArgs());
});
await _hubConnection.StartAsync();
}
public void ReadCallback(IAsyncResult ar)
{
// Retrieve the state object and the handler socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;
// Read data from the client socket.
int bytesRead = handler.EndReceive(ar);
int newDataPoint = 0;
if (state.data == null)
{
state.data = new byte[bytesRead];
}
else if (bytesRead != 0)
{
//this can be more efficient probably
newDataPoint = state.data.Length;
byte[] tempStorage = new byte[state.data.Length];
state.data.CopyTo(tempStorage, 0);
state.data = new byte[state.data.Length + bytesRead];
tempStorage.CopyTo(state.data, 0);
}
if (bytesRead > 0)
{
if (state.data.Length > 1024)
{
state.buffer.CopyTo(state.data, newDataPoint);
}
else
{
//first transfer
state.data = state.buffer;
}
handler.BeginReceive(state.buffer, 0, 1024, 0,
new AsyncCallback(ReadCallback), state);
}
else
{
OnReceivedMessage?.Invoke(this, new ReceivedMessageEventArgs()
{
ConnectedSocket = state.workSocket, Data = state.data
});
}
}
private void Receive()
{
try
{
byte[] _receiveBuffer = new byte[_socket.Available]; // Read everything, that is available at once!
EndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, Port);
_socket.ReceiveFrom(_receiveBuffer, 0, _receiveBuffer.Length, SocketFlags.None, ref ipEndPoint);
if (ListenToAllAdresses == false)
{
IPAddress connectedAddress = ((IPEndPoint)ipEndPoint).Address;
if (_remoteIp == null) // Only happens the first time or if _listenToAllAdresses was set to false during runtime.
{
_remoteIp = IPAddress.Parse(_remoteIpAddress);
}
if (connectedAddress.Equals(_remoteIp) == false)
{
Debug.LogWarning("Got network package from unaccepted endpoint (" + connectedAddress.ToString() + "). Expected endpoint is " + _remoteIpAddress + "."
+ "\nPackage is not going to be read!");
return;
}
}
if (_receiveBuffer != null && _receiveBuffer.Length > 0) // If we received some bytes:
{
// Call each subscriber that bytes have been received:
foreach (ReceivedMessageDelegate ReceiveCallack in OnReceivedMessage.GetInvocationList())
{
try
{
ReceiveCallack(_receiveBuffer, ((IPEndPoint)ipEndPoint).Address);
}
catch (System.Exception ex)
{
Debug.LogException(ex);
}
}
}
}
catch (Exception receiveException)
{
Debug.LogException(receiveException);
}
}
public async Task InitAsync(string userId)
{
await semaphoreSlim.WaitAsync();
if (httpClient == null)
{
httpClient = new HttpClient();
}
var result = await httpClient
.GetStringAsync($"{Config.NegotiateEndpoint}/{userId}");
var info = JsonConvert.DeserializeObject <ConnectionInfo>(result);
var connectionBuilder =
new HubConnectionBuilder();
connectionBuilder.WithUrl(info.Url, (obj) =>
{
obj.AccessTokenProvider = () => Task.Run(() => info.AccessToken);
})
.WithAutomaticReconnect()
;
hub = connectionBuilder.Build();
await hub.StartAsync();
ConnectionToken = hub.ConnectionId;
IsConnected = true;
hub.On <object>("ReceiveMessage", (message) =>
{
var json = message.ToString();
var obj = JsonConvert.DeserializeObject <ChatMessage>(json);
var msg = (ChatMessage)JsonConvert
.DeserializeObject(json, obj.TypeInfo);
OnReceivedMessage?.Invoke(this, new MessageEventArgs(msg));
});
semaphoreSlim.Release();
}
public async Task Connect()
{
ClientWebSocket socket = new ClientWebSocket();
await socket.ConnectAsync(new Uri("wss://ws-feed.gdax.com"), CancellationToken.None);
if (socket.State == WebSocketState.Open)
{
string json = JsonConvert.SerializeObject(new
{
type = "subscribe",
product_ids = new[] { "ltc-usd" },
channels = new[] { "level2" }
});
byte[] requestBytes = UTF8Encoding.UTF8.GetBytes(json);
await socket.SendAsync(new ArraySegment <byte>(requestBytes), WebSocketMessageType.Text, true, new CancellationToken());
while (socket.State == WebSocketState.Open)
{
List <byte> memory = new List <byte>();
byte[] recBytes = new byte[1024];
while (true)
{
ArraySegment <byte> t = new ArraySegment <byte>(recBytes);
WebSocketReceiveResult receiveAsync = await socket.ReceiveAsync(t, CancellationToken.None);
string jsonString = Encoding.UTF8.GetString(recBytes);
OnReceivedPacket.Invoke(jsonString);
byte[] corrected = t.Array.Where(x => x != 0).ToArray();
memory.AddRange(corrected);
recBytes = new byte[1024];
if (receiveAsync.EndOfMessage)
{
break;
}
}
string text = Encoding.ASCII.GetString(memory.ToArray());
OnReceivedMessage.Invoke(JsonConvert.DeserializeObject <WebSocketResponse>(text), text);
}
}
}
/// <summary>
/// Listen to messages received
/// </summary>
public void Listen()
{
mqttClient.UseApplicationMessageReceivedHandler(e =>
{
var payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
if (payload.Contains("message\":\"On\""))
{
OnReceivedCommand?.Invoke(true);
}
else if (payload.Contains("message\":\"Off\""))
{
OnReceivedCommand?.Invoke(false);
}
else
{
OnReceivedMessage?.Invoke(this, new MqttIoTIgniteReceivedMessageEventArgs(e));
}
});
}
private void _client_OnData(object sender, byte[] data)
{
var userToken = (WSUserToken)_client.ReceiveSocket.UserToken;
if (!userToken.HandShaked)
{
userToken.HandShaked = true;
OnConnected?.Invoke(this);
}
else
{
userToken.UnPackage(data, (rdata) =>
{
OnReceived?.Invoke(rdata);
OnReceivedMessage?.Invoke(Helper.SerializeHelper.ProtolBufDeserialize <Model.WSMessage>(rdata));
});
}
}
private void AcceptCallback(object sender, SocketAsyncEventArgs e)
{
LogMessage("Message Received");
Socket listenSocket = (Socket)sender;
do
{
try
{
Socket newSocket = e.AcceptSocket;
Debug.Assert(newSocket != null);
byte[] bytes = new Byte[1024];
int bytesRec = newSocket.Receive(bytes);
OnReceivedMessage?.Invoke(sender, new ReceivedMessageEventArgs()
{
Data = bytes, ConnectedSocket = newSocket
});
//var messageWrapper = new MessageWrapper() { MessageType = MessageType.InfoOnlyMessage };
//var messageData = new InfoOnlyMessage() { Message = "Received!" };
//messageWrapper.Data = messageData;
//newSocket.Send(messageWrapper.ObjectToByteArray());
//newSocket.Disconnect(false);
//newSocket.Close();
}
catch (Exception ex)
{
LogMessage(ex.Message);
}
finally
{
//to enable reuse
e.AcceptSocket = null;
}
} while (!listenSocket.AcceptAsync(e));
}
void ThreadReceive()
{
while (doReceive)
{
try
{
if (socket.Available <= 0)
{
continue;
}
byte[] buffer = new byte[BufferSize];
int length = socket.Receive(buffer);
if (length > 0)
{
byte[] message = new byte[length];
Buffer.BlockCopy(buffer, 0, message, 0, length);
ConnectionReceiveEventArgs newClientMessage = new ConnectionReceiveEventArgs(Name, message);
if (OnReceivedMessage != null)
{
OnReceivedMessage.Invoke(this, newClientMessage);
}
if (closeForCommand && newClientMessage.MessageType == DataType.Close)
{
Close(false);
}
}
}
catch (Exception ex)
{
if (doReceive)
{
HandleConnectionException(ex);
}
}
}
}
private async Task HandleReceivedMessageAsync(Telegram.Bot.Types.Message message)
{
var messageID = message.MessageId;
if (_callbackActions.ContainsKey(messageID))
{
await _callbackActions[messageID](new CallbackQuery()
{
Data = message.Text,
From = message.From,
Message = message
});
_callbackActions.Remove(messageID);
}
else if (message.Type == Telegram.Bot.Types.Enums.MessageType.Text)
{
await HandleUserInfoCommand(message);
if (AnswerMessage(message.From.Id) && OnReceivedMessage != null)
{
OnReceivedMessage.Invoke(this, message.Text);
}
}
}
IEnumerator DispatchOnReceived(string msg)
{
OnReceivedMessage?.Invoke(msg);
yield return(null);
}
internal void HandleReceiveMessage(AVIMConversation conversation, AVIMMessage message)
{
message.Conversation = conversation;
OnReceivedMessage?.Invoke(message);
}
public void FromApp(Message message, SessionID sessionID)
{
OnReceivedMessage?.Invoke(message);
}
public void Init(string urlRoot, string portNumber, bool useHttps)
{
//-----ITvitae server url = "10.10.1.34"-----//
//-----ITvitae server port = "4444"-----//
string url = $"http{(useHttps ? "s" : String.Empty)}://{urlRoot}:{portNumber}/hubs/chat";
//string url = $"http://{urlRoot}:{portNumber}/hubs/chat";
// Setup the hubconnection with the newly created url
hubConnection = new HubConnectionBuilder()
.WithUrl(url)
.Build();
// Initialize random so we can use it to randomize colors
random = new Random();
// Setup the hubConnection events
hubConnection.Closed += async(error) =>
{
OnConnectionClosed?.Invoke(this, new MessageEventArgs("Connection closed...", DateTime.Now, string.Empty));
IsConnected = false;
// Wait a little and try to reconnect
await Task.Delay(random.Next(0, 5) * 1000);
try
{
await ConnectAsync();
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
};
// Receive message
hubConnection.On <string, DateTime, string>("ReceiveMessage", (user, dateTime, message) =>
{
OnReceivedMessage?.Invoke(this, new MessageEventArgs(user, dateTime, message));
});
// Receive file
hubConnection.On <string, DateTime, string, string>("ReceiveFile", (user, dateTime, folderName, fileName) =>
{
OnReceivedFile?.Invoke(this, new FileEventArgs(user, dateTime, folderName, fileName));
});
// Entered
hubConnection.On <string, DateTime>("Entered", (user, dateTime) =>
{
OnEnteredOrExited?.Invoke(this, new MessageEventArgs(user, dateTime, $"{user} entered."));
});
// Exited
hubConnection.On <string, DateTime>("Left", (user, dateTime) =>
{
OnEnteredOrExited?.Invoke(this, new MessageEventArgs(user, dateTime, $"{user} left."));
});
// Entered or left ??? <--- WTF (vanuit tutorial, geen idee waar voor nodig)
hubConnection.On <string, DateTime>("EnteredOrLeft", (message, dateTime) =>
{
OnEnteredOrExited?.Invoke(this, new MessageEventArgs("???Someone???", dateTime, message));
});
}
