/// <summary>
/// Returns the hardcoded client revision string from the Outgoing[4000] message class.
/// </summary>
/// <returns></returns>
public string GetClientRevision()
{
if (!string.IsNullOrWhiteSpace(_clientRevision))
{
return(_clientRevision);
}
if (!(OutgoingMessages?.ContainsKey(4000) ?? false))
{
return(string.Empty);
}
ASInstance outgoingInstance = OutgoingMessages[4000].Instance;
ASMethod method = outgoingInstance.FindFirstMethod(null, "Array");
if (method == null)
{
return(string.Empty);
}
using (var inCode = new FlashReader(method.Body.Bytecode))
{
object[] values = inCode.ReadValuesUntil(OPCode.PushString);
var pushStringIndex = (int)values[0];
_clientRevision = method.ABC.Constants.Strings[pushStringIndex];
}
return(_clientRevision);
}
protected void Send(BytePacket <T> packet)
{
OutgoingMessages.Enqueue(new NetworkMessage <T> {
Packet = packet
});
LatestSendTimestamp = DateTime.Now;
}
private void FlushOutgoingPackets()
{
int outQCount = OutgoingMessages.Count;
// write out queued messages
for (int i = 0; i < outQCount; i++)
{
NetworkMessage <T> packet;
bool have = OutgoingMessages.TryDequeue(out packet);
if (have)
{
if (packet.TargetAddress == null)
{
packet.Packet.Send(UdpSocket);
}
else
{
packet.Packet.Send(UdpSocket, packet.TargetAddress);
}
PacketsSent++;
TotalBytesSent += packet.Packet.Payload.Length;
InternalSendCount += packet.Packet.Payload.Length;
}
}
}
protected async void Run(CancellationToken cancellationToken, Uri uri)
{
WebSocket = new ClientWebSocket();
OnConnecting();
WebSocket = await Connection.OpenConnection(WebSocket, uri);
if (WebSocket.State == WebSocketState.Open)
{
OnConnected();
}
while (WebSocket.State == WebSocketState.Open)
{
if (cancellationToken.IsCancellationRequested)
{
await Cancel(WebSocket);
break;
}
ICommand message = null;
lock (queueLock)
{
message = OutgoingMessages.Any() ? OutgoingMessages.Dequeue() : null;
}
if (message != null)
{
await SendMessage(WebSocket, message);
}
}
System.Diagnostics.Trace.WriteLine($"Connection closed. Reason: {WebSocket.CloseStatus}, Details: {WebSocket.CloseStatusDescription}");
OnDisconnect();
}
public void AddMessage(ICommand message)
{
lock (queueLock)
{
OutgoingMessages.Enqueue(message);
}
}
private void Send()
{
while (IsRunning)
{
var message = OutgoingMessages.Take();
}
}
protected void Send(BytePacket <T> packet, IPEndPoint target)
{
OutgoingMessages.Enqueue(new NetworkMessage <T> {
Packet = packet,
TargetAddress = target,
});
LatestSendTimestamp = DateTime.Now;
}
/// <summary>
/// Gets the outgoing messages for the incoming message with the given ID
/// </summary>
public IEnumerable <OutgoingMessage> GetOutgoingMessages(string messageId)
{
var outgoingMessages = OutgoingMessages.FirstOrDefault(o => o.MessageId == messageId);
return(outgoingMessages != null
? outgoingMessages.MessagesToSend
: Enumerable.Empty <OutgoingMessage>());
}
void IDataStore.Save(OutgoingSmsMessage msg)
{
if (!OutgoingMessages.Any(m => m.Id == msg.Id))
{
OutgoingMessages.Add(msg);
}
SaveChanges();
}
public void Send()
{
var message = OutgoingMessages.Take(TokenSource.Token);
MessageWaitHandle.WaitOne();
TwitchClient.SendMessage(message.Msg);
MessageWaitHandle.Reset();
MessageTimer.Start();
}
public void ProcessOutgoingQueue()
{
StringBuilder s = new StringBuilder();
s.Append(Comms.Base64NetID + Comms.myClient.IDBase64 + '?');
foreach (RawMessage m in OutgoingMessages)
{
s.Append(FormatMessageToString(m) + '\n');
}
Comms.TransmitString(s.ToString());
OutgoingMessages.Clear();
}
/// <summary>
/// Enqueue message thread safe
/// </summary>
/// <param name="message"></param>
internal void AddMessageToQueue(SinricMessage message)
{
var payloadJson = JsonConvert.SerializeObject(message.Payload);
message.RawPayload = new JRaw(payloadJson);
// compute the signature using our secret key so that the service can verify authenticity
message.Signature.Hmac = HmacSignature.Signature(payloadJson, SecretKey);
OutgoingMessages.Enqueue(message);
Debug.Print("Queued websocket message for sending");
}
void IDataStore.Remove(OutgoingSmsMessage message)
{
if (message != null)
{
foreach (OutgoingSmsMessage msg in OutgoingMessages.Where(m => m.Id == message.Id))
{
OutgoingMessages.Remove(msg);
}
SaveChanges();
}
}
void IDataStore.ScheduleMessage(OutgoingSmsMessage msg, Subscription sub)
{
OutgoingMessages.Add(msg);
Subscription toUpdate = Subscriptions.Where(s => s.Id == sub.Id).FirstOrDefault();
if (toUpdate != null)
{
toUpdate.Next = DateTime.Today.AddDays(1).AddHours(4).ToUniversalTime();
}
SaveChanges();
}
void IDataStore.RemoveAllForPhone(string phone)
{
foreach (OutgoingSmsMessage msg in OutgoingMessages.Where(m => m.Destination == phone))
{
OutgoingMessages.Remove(msg);
}
foreach (Subscription sub in Subscriptions.Where(s => s.Phone == phone))
{
Subscriptions.Remove(sub);
}
SaveChanges();
}
/// <summary>
/// Creates the idempotency data object, initializing it with the given list of outgoing message lists and record of handled message IDs
/// </summary>
public IdempotencyData(IEnumerable <OutgoingMessages> outgoingMessages = null, IEnumerable <string> handledMessageIds = null)
{
if (outgoingMessages != null)
{
OutgoingMessages.AddRange(outgoingMessages);
}
if (handledMessageIds != null)
{
foreach (var id in handledMessageIds)
{
HandledMessageIds.Add(id);
}
}
}
OutgoingMessages GetOrCreate(string messageId)
{
HandledMessageIds.Add(messageId);
var outgoingMessages = OutgoingMessages.FirstOrDefault(o => o.MessageId == messageId);
if (outgoingMessages != null)
{
return(outgoingMessages);
}
outgoingMessages = new OutgoingMessages(messageId, new List <OutgoingMessage>());
OutgoingMessages.Add(outgoingMessages);
return(outgoingMessages);
}
public void SendNewState <T>(T stateEnumValue) where T : Enum
{
// actionVerb will be the description of the enum, ie. setContactState
var actionVerb = SinricActionAttribute.GetActionVerb(stateEnumValue.GetType());
var newState = SetLocalState(stateEnumValue);
// send a message to the server indicating new state
var message = NewMessage(SinricPayload.MessageType.Event);
message.Payload.SetCause(SinricCause.CauseType, SinricCause.PhysicalInteraction);
message.Payload.SetValue(SinricValue.State, newState);
message.Payload.Action = actionVerb;
// queue for sending
OutgoingMessages.Enqueue(message);
}
/// <summary>
/// This should be call before doing final storage, will reduce the size of
/// unused fields
/// </summary>
public void SetEmptyValueToNull()
{
foreach (var err in ErrorMessages)
{
err.SetEmptyValueToNull();
}
if (String.IsNullOrEmpty(MediaItemId))
{
MediaItemId = null;
}
if (String.IsNullOrEmpty(MessageId))
{
MessageId = null;
}
if (!Log.Any())
{
Log = null;
}
if (!OutputCommands.Any())
{
OutputCommands = null;
}
if (!OutgoingMessages.Any())
{
OutgoingMessages = null;
}
if (!ErrorMessages.Any())
{
ErrorMessages = null;
}
if (!InfoMessages.Any())
{
InfoMessages = null;
}
if (!WarningMessages.Any())
{
WarningMessages = null;
}
if (Envelope.SetEmptyValueToNull())
{
Envelope = null;
}
}
public void RemoveAllForPhone(string phone)
{
lock (_lock)
{
IList <OutgoingSmsMessage> outgoing = OutgoingMessages.Where(m => m.Destination == phone).ToList();
foreach (OutgoingSmsMessage msg in outgoing)
{
Remove(msg);
}
IList <Subscription> subs = Subscriptions.Where(s => s.Phone == phone).ToList();
foreach (Subscription sub in subs)
{
Remove(sub);
}
}
}
/// <summary>
/// Main sending thread
/// </summary>
public static void SendMain()
{
try
{
while (!MainSystem.Singleton.Quit)
{
IMessageBase sendMessage;
if (OutgoingMessages.TryDequeue(out sendMessage))
{
SendNetworkMessage(sendMessage);
}
else
{
Thread.Sleep(SettingsSystem.CurrentSettings.SendReceiveMsInterval);
}
}
}
catch (Exception e)
{
Debug.LogError("[LMP]: Send thread error: " + e);
}
}
public void SendHeartbeatToAll()
{
RawMessage m = new RawMessage(Comms.myClient.ID, true, MessageType.HEARTBEAT, new byte[0]);
OutgoingMessages.Add(m);
}
public void SendDisconnectMessage()
{
OutgoingMessages.Add(new RawMessage(0, true, MessageType.DISCONNECT, new byte[0]));
}
/// <summary>
/// Adds a new message to the queue
/// </summary>
/// <param name="message"></param>
public static void QueueOutgoingMessage(IMessageBase message)
{
OutgoingMessages.Enqueue(message);
}
public void SetMessageHandlers(IKeyboardMouseInput keyboardMouse)
{
OutgoingMessages = new OutgoingMessages(Connection);
MessageHandlers.ApplyConnectionHandlers(Connection, this, keyboardMouse);
}
public void SendClientStatusUpdate(Client receiver)
{
RawMessage m = new RawMessage(receiver.AvailableID, false, MessageType.UPDATESTATUS, Comms.myClient.SerializeClientData());
OutgoingMessages.Add(m);
}
public static void AddParameter(this List <byte> source, OutgoingMessages msgId)
{
AddParameter(source, (int)msgId);
}
public void AddMessage(IKalos message)
{
OutgoingMessages.Add(message);
}
public static void AddParameter(this BinaryWriter source, OutgoingMessages msgId)
{
AddParameter(source, (int)msgId);
}
public void SendConnectMessage()
{
RawMessage m = new RawMessage(0, true, MessageType.CONNECT, Comms.myClient.SerializeClientData());
OutgoingMessages.Add(m);
}
