public static void NotifyNewMessage(RestreamChatMessage message)
{
if (message != null && m_onNewMessage != null)
{
m_onNewMessage(message);
}
}
public static void MaxMessagesSize(ref RestreamChatMessage message, int maxSize = 250)
{
if (message.Message.Length >= maxSize)
{
message.Message = message.Message.Substring(0, maxSize);
}
}
private static void TryConvertMessageItemHtmlDivTOMessage(string messageRaw, out bool hasFoundOne, out bool hadconvertionError, out RestreamChatMessage messageFound)
{
hasFoundOne = false;
hadconvertionError = false;
messageFound = null;
if (messageRaw.IndexOf("message-text") < 0)
{
return;
}
if (messageRaw.IndexOf("message-sender") < 0)
{
return;
}
if (messageRaw.IndexOf("message-time") < 0)
{
return;
}
try
{
messageFound = new RestreamChatMessage();
messageFound.SetDateToNow();
messageFound.Message = GetValueOf(messageRaw, "message-text");
messageFound.UserName = GetValueOf(messageRaw, "message-sender");
messageFound.When = GetValueOf(messageRaw, "message-time");
messageFound.SetPlatform(GetPlatformId(messageRaw));
hasFoundOne = messageFound.IsValuesDefined();
hadconvertionError = false;
}
catch (Exception) {
messageFound = null;
hasFoundOne = false;
hadconvertionError = true;
}
}
private static void ThrowMessageToListeners(RestreamChatMessage message)
{
if (sendOSCMessages == null &&
ChatHackerConfiguration.Instance.m_useOsc)
{
sendOSCMessages = new ThrowOSC(
ChatHackerConfiguration.Instance.m_oscAddress,
ChatHackerConfiguration.Instance.m_oscPort);
}
if (sendUDPListeners == null &&
ChatHackerConfiguration.Instance.m_useUdp)
{
string[] ips = ChatHackerConfiguration.Instance.m_udpAddressListeners;
sendUDPListeners = new MessageCommunication.IThrow[ips.Length];
for (int i = 0; i < ips.Length; i++)
{
sendUDPListeners[i] = new ThrowUDP(
ips[i],
ChatHackerConfiguration.Instance.m_udpPort);
}
}
if (sendOSCMessages != null)
{
sendOSCMessages.SendChatMessage(message);
}
if (sendUDPListeners != null)
{
for (int i = 0; i < sendUDPListeners.Length; i++)
{
sendUDPListeners[i].SendChatMessage(message);
}
}
}
public static void ThrowMessages(RestreamChatMessage message)
{
if (m_onMessageDetected != null)
{
m_onMessageDetected(message);
}
}
public static RestreamChatMessage CreateInstance(string pseudo, string message, ChatPlatform platform = ChatPlatform.Mockup)
{
RestreamChatMessage msg = new RestreamChatMessage(pseudo, message);
msg.SetPlatform(platform);
return(msg);
}
public RestreamChatMessage Duplicate()
{
RestreamChatMessage duplicate = new RestreamChatMessage();
duplicate.SetWithOneLiner(GetAsOneLiner());
return(duplicate);
}
//void SendMessage(IEnumerable<RestreamChatMessage> messagesGroup)
//{
// foreach (var message in messagesGroup)
// {
// this.SendMessage(message);
// }
//}
void SendMessage(RestreamChatMessage message)
{
//Console.WriteLine("UDP -> " + message);
if (m_sender != null && message != null)
{
m_sender.Send(message.GetAsOneLiner());
}
}
public static RestreamChatMessage CreateFakeMessage(string userName, string message, ChatPlatform mockup)
{
RestreamChatMessage chatMessage = new RestreamChatMessage(userName, message);
chatMessage.SetPlatform(mockup);
chatMessage.SetDateToNow();
return(chatMessage);
}
public void AddMessageToRegister(ref RestreamChatMessage message, out bool wasPresent)
{
string id = message.GetUniqueId();
wasPresent = m_stringIdArchive.ContainsKey(id);
if (!wasPresent)
{
m_stringIdArchive.Add(id, (long)(DateTime.Now - m_startOfPoint).TotalSeconds);//Should and the timestamp
}
}
public override void SendChatMessage(RestreamChatMessage message)
{
try
{
sender.Send(new OscMessage("/RCH_Message", message.GetAsOneLiner()));
}
catch (System.Net.Sockets.SocketException) {
Console.WriteLine("ERROR ! The port " + PortOut + " is used by some an other application.");
}
}
public static void StopStreaming(RestreamChatMessage message)
{
if (ChatHackerConfiguration.Instance.m_allowSteamKillingFromChat)
{
if (message.Message.Contains(ChatHackerConfiguration.Instance.m_killStreamWord))
{
Console.WriteLine("Action: Try to stop streaming");
LaunchBat("StopStreaming");
}
}
}
private static void UseMockUData()
{
int count = 0;
while (m_thread != null)
{
RestreamChatMessage chatMessage = FakeChatMessageGenerator.CreateFakeMessage("Fake User", "I am a message test " + count++, ChatPlatform.Mockup);
ExportToOtherApps.ThrowMessages(chatMessage);
Thread.Sleep(1000);
}
}
public static void LaunchStreaming(RestreamChatMessage message)
{
if (ChatHackerConfiguration.Instance.m_allowSteamLaunchingFromChat)
{
if (message.Message.Contains(ChatHackerConfiguration.Instance.m_startStreamKeyword))
{
Console.WriteLine("Action: Try to launch streaming");
LaunchBat("StartStreamingOBS");
}
}
}
public static void AddMessageToRegister(RestreamChatMessage message)
{
if (message == null)
{
return;
}
if (m_maxMemoryMessages <= m_registeredMessages.Count)
{
m_registeredMessages.Dequeue();
}
m_registeredMessages.Enqueue(message);
Restream.Listener.NotifyNewMessage(message);
}
public void AddMessagesAndRecovertNewInList(ref List <RestreamChatMessage> foundMessageInPage, out List <RestreamChatMessage> newMessageInPage)
{
newMessageInPage = new List <RestreamChatMessage>();
bool wasInRecord;
for (int i = 0; i < foundMessageInPage.Count; i++)
{
RestreamChatMessage refMessage = foundMessageInPage[i];
AddMessageToRegister(ref refMessage, out wasInRecord);
if (!wasInRecord)
{
newMessageInPage.Add(refMessage);
}
}
}
public bool Equals(RestreamChatMessage other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Message.Equals(other.Message) &&
When.Equals(other.When) &&
UserName.Equals(other.UserName) &&
Date.Equals(Date));
}
public static void CreateFromOneLiner(string oneliner, out bool succed, out RestreamChatMessage message)
{
message = new RestreamChatMessage();
message.SetWithOneLiner(oneliner);
succed = message.IsCorrectlyDefined();
}
public static void DisplayMessage(RestreamChatMessage message)
{
Console.WriteLine(string.Format(">> {3} | {0},{1}:{2}", message.UserName, message.When, message.Message, message.Platform));
}
public void SendChatMessage(RestreamChatMessage message)
{
Write(ConvertToJson(message));
}
public abstract void SendChatMessage(RestreamChatMessage message);
void IThrow.SendChatMessage(RestreamChatMessage message)
{
SendMessage(message);
}
public string CompressedMessage(RestreamChatMessage msg)
{
//To Change later to a really compressed string
return(msg.ToString());
}
public static string ConvertToJson(RestreamChatMessage message)
{
return(JsonConvert.SerializeObject(message));
}
public void SendChatMessage(RestreamChatMessage message)
{
SendMailByGoogle(message.ToString());
}
