public void ConversationStarterTest()
{
LocalUser user = UnitTestAuth.Login();
var status = ConversationStartStatus.UnknownError;
bool done = false;
Conversation conversation = null;
Dictionary <String, User> users = null;
var starter = ConversationSystemManager.NewConversationStarter();
starter.Result += (_status, _conversation, _users) =>
{
status = _status;
conversation = _conversation;
users = _users;
done = true;
};
starter.StartConversation("test4");
while (!done)
{
}
Assert.AreEqual(status, ConversationStartStatus.Success);
Assert.AreNotEqual(conversation, null);
Assert.AreNotEqual(users, null);
Assert.AreNotEqual(users["test4"], null);
}
private void StartConversation_Clicked(object sender, EventArgs e)
{
var conversationStarter = ConversationSystemManager.NewConversationStarter();
LoadingIndicator.IsRunning = true;
StartConversation.IsEnabled = false;
conversationStarter.Result += (status, conversation, users) =>
{
Device.BeginInvokeOnMainThread(async() => //Grįžtama į main Thread !! SVARBU
{
if (status == ConversationStartStatus.Success) //Pavyko
{
await Navigation.PushModalAsync(
new NavigationPage(
new ConversationPage(
new ViewModels.ConversationViewModel(conversation, users))));
DependencyService.Get <IToast>().LongToast("Pokalbis pradėtas");
}
else //Ne
{
await Application.Current.MainPage.DisplayAlert("Klaida", "woops, kažkas netaip", "tęsti");
}
LoadingIndicator.IsRunning = false;
StartConversation.IsEnabled = true;
});
};
conversationStarter.StartConversation(user.Username);
}
public void ConversationGetterTest()
{
LocalUser user = UnitTestAuth.Login();
var status = ConversationGetStatus.UnknownError;
bool done = false;
List <Conversation> conversations = null;
Dictionary <String, User> users = null;
var getter = ConversationSystemManager.NewConversationGetter();
getter.Result += (_status, _conversations, _users) =>
{
status = _status;
conversations = _conversations;
users = _users;
done = true;
};
getter.GetUsers = true;
getter.GetConversations();
while (!done)
{
}
Assert.AreEqual(status, ConversationGetStatus.Success);
Assert.AreNotEqual(users, null);
Assert.AreNotEqual(conversations, null);
}
public void ConversationFullTest()
{
LocalUser user = UnitTestAuth.Login(username: "******", password: "******");
var statusGetterConversation = ConversationGetStatus.UnknownError;
var statusStarter = ConversationStartStatus.UnknownError;
var statusPoster = MessageSendStatus.UnknownError;
var statusGetterMessages = MessageGetAllStatus.UnknownError;
bool done = false;
Conversation conversation = null;
Message message = null;
Dictionary <int, List <Message> > messages = null;
List <Conversation> conversations = null;
Dictionary <String, User> users = null;
var getterConv = ConversationSystemManager.NewConversationGetter();
getterConv.Result += (_status, _conversations, _users) => {
statusGetterConversation = _status;
conversations = _conversations;
users = _users;
done = true;
};
var conversationStarter = ConversationSystemManager.NewConversationStarter();
conversationStarter.Result += (_status, _conversation, _users) =>
{
statusStarter = _status;
conversation = _conversation;
users = _users;
done = true;
};
var messagePoster = ConversationSystemManager.NewMessageSender();
messagePoster.Result += (_status, _message) =>
{
statusPoster = _status;
message = _message;
done = true;
};
var messageGetter = ConversationSystemManager.NewMessageGetter();
messageGetter.Result += (_status, _conversations, _messages, _users) =>
{
statusGetterMessages = _status;
conversations = _conversations;
messages = _messages;
users = _users;
done = true;
};
///Pradedam Conversation
done = false;
conversationStarter.StartConversation("test4");
while (!done)
{
}
Assert.AreEqual(statusStarter, ConversationStartStatus.Success);
Assert.AreNotEqual(conversation, null);
Assert.AreNotEqual(users, null);
Assert.AreNotEqual(users["test4"], null);
///
///Gaunam messages
done = false;
messageGetter.GetMessages();
while (!done)
{
}
Assert.AreEqual(statusGetterMessages, MessageGetAllStatus.Success);
Assert.AreNotEqual(messages, null);
Assert.AreNotEqual(conversations, null);
Assert.AreNotEqual(users, null);
var timestamp = (messages.ContainsKey(conversation.Id) && messages[conversation.Id].Count > 0 ? messages[conversation.Id][messages[conversation.Id].Count - 1].Timestamp : 0);
///
///Siunčiam message
var random = new Random();
done = false;
messagePoster.StartSending();
messagePoster.AddMessageToQueue(new Message
{
Conversation = conversation.Id,
Text = random.Next().ToString()
});
while (!done)
{
}
Assert.AreEqual(statusPoster, MessageSendStatus.Success);
Assert.AreNotEqual(message, null);
///
///Gaunam messages
done = false;
messageGetter.TimeStamp = timestamp;
messageGetter.GetMessages();
while (!done)
{
}
Assert.AreEqual(statusGetterMessages, MessageGetAllStatus.Success);
Assert.AreNotEqual(messages, null);
Assert.AreNotEqual(conversations, null);
Assert.AreNotEqual(users, null);
Assert.AreEqual(messages.ContainsKey(conversation.Id), true);
///Tikrinam ar nusisiuntė
var myMessage = messages[conversation.Id].Find((_message) =>
{
return(_message.Text == message.Text &&
_message.Username == user.Username);
});
Assert.AreNotEqual(myMessage, null);
///
///Gaunam conversations
done = false;
getterConv.GetUsers = true;
getterConv.GetConversations();
while (!done)
{
}
Assert.AreEqual(statusGetterConversation, ConversationGetStatus.Success);
Assert.AreNotEqual(users, null);
Assert.AreNotEqual(conversations, null);
var myConversation = conversations.Find((_conversation) =>
{
return(_conversation.Id == conversation.Id);
});
Assert.AreNotEqual(myConversation, null);
///
}
public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
{
Device.BeginInvokeOnMainThread(() =>
{
DependencyService.Get <IToast>().ShortToast("starting service");
});
if (messageGetter != null)
{
return(StartCommandResult.Sticky);
}
if (App.Current.Properties.ContainsKey("notificationTimestamp"))
{
notificationTimestamp = (long)App.Current.Properties["notificationTimestamp"];
}
if (LocalUserManager.LocalUser == null)
{
if (Xamarin.Forms.Application.Current.Properties.ContainsKey("PrivateKey"))
{
LocalUserManager.LocalUser = new LocalUser {
PrivateKey = (string)Xamarin.Forms.Application.Current.Properties["PrivateKey"]
};
}
else
{
Device.BeginInvokeOnMainThread(() =>
{
DependencyService.Get <IToast>().ShortToast("no private key");
});
Stop();
}
}
Device.BeginInvokeOnMainThread(() =>
{
DependencyService.Get <IToast>().ShortToast("started service");
});
messageGetter = ConversationSystemManager.NewMessageGetter();
messageSender = ConversationSystemManager.NewMessageSender();
//Message getter result
messageGetter.Result += (status, conversations, messages, users) => {
Device.BeginInvokeOnMainThread(() =>
{
//DependencyService.Get<IToast>().ShortToast(status.ToString());
});
//Got messages
if (status == MessageGetAllStatus.Success && conversations.Count != 0)
{
//joining conversations
this.conversations = conversations
.Union(this.conversations, new EntityComparer())
.OrderByDescending(conv => conv.LastActivity)
.ToList();
//Joining messages
foreach (KeyValuePair <int, List <Message> > entry in messages)
{
if (this.messages.ContainsKey(entry.Key))
{
this.messages[entry.Key].AddRange(entry.Value);
}
else
{
this.messages[entry.Key] = entry.Value;
}
}
//Joining users
this.users = users
.Concat(this.users.Where(pair => !users.ContainsKey(pair.Key)))
.ToDictionary(x => x.Key, x => x.Value);
//Sending messages back to ui
Device.BeginInvokeOnMainThread(() =>
{
MessagingCenter.Send(new MessagingTask(messagesDict: messages, users: this.users), MessagingTask.NewMessages);
DependencyService.Get <IToast>().ShortToast("New message");
});
//Saving values
try
{
foreach (var entry in users)
{
if (db.Users.Any(user => user.Username == entry.Value.Username))
{
db.Users.Update(entry.Value);
}
else
{
db.Users.Add(entry.Value);
}
}
foreach (var entry in conversations)
{
if (db.Conversations.Any(conv => conv.Id == entry.Id))
{
db.Conversations.Update(entry);
}
else
{
db.Conversations.Add(entry);
}
}
foreach (var entry in messages)
{
foreach (var message in entry.Value)
{
if (db.Messages.Any(_message => _message.Id == message.Id))
{
db.Messages.Update(message);
}
else
{
db.Messages.Add(message);
}
}
}
db.SaveChanges();
//Untracking values
foreach (var entry in users)
{
db.Entry(entry.Value).State = EntityState.Detached;
}
foreach (var entry in conversations)
{
db.Entry(entry).State = EntityState.Detached;
}
foreach (var entry in messages)
{
foreach (var message in entry.Value)
{
db.Entry(message).State = EntityState.Detached;
}
}
}
catch (SqliteException e)
{
Console.WriteLine("Table not found, the user might have logged off mid writing");
}
//Creating notifications
long temp = notificationTimestamp;
conversations.ForEach((conversation) =>
{
Message message = messages[conversation.Id].FindLast(m => users.ContainsKey(m.Username) && m.Timestamp > notificationTimestamp);
if (message != null)
{
if (notificationTimestamp != -1)
{
Device.BeginInvokeOnMainThread(() =>
{
DependencyService.Get <INotification>().DisplayMessageNotification(conversation, message, users);
});
}
temp = Math.Max(message.Timestamp, temp);
}
});
//New notification timestamp limit
if (temp != notificationTimestamp)
{
notificationTimestamp = temp;
App.Current.Properties["notificationTimestamp"] = notificationTimestamp;
App.Current.SavePropertiesAsync();
}
}
//Failed to get stopping service
else if (status == MessageGetAllStatus.InvalidPrivateKey)
{
if (LocalUserManager.LocalUser != null)
{
messageGetter.PrivateKey = LocalUserManager.LocalUser.PrivateKey;
}
else
{
messageGetter.Result = null;
messageGetter.StopGetting();
messageSender.Result = null;
messageSender.StopSending();
Stop();
}
}
};
//Get all messages request
MessagingCenter.Subscribe <MessagingTask>(this, MessagingTask.GetMessages, (task) =>
{
MessagingCenter.Send(new MessagingTask(messagesDict: messages, users: users), MessagingTask.LocalMessages);
});
//Get specfic amoount of messages
MessagingCenter.Subscribe <MessagingTask>(this, MessagingTask.GetMessagesLimited, (task) =>
{
List <Message> messagesList = null;
if (messages.ContainsKey(task.Conversation.Id))
{
int toRemove = (task.Message == null ? 0 : messages[task.Conversation.Id].Count - messages[task.Conversation.Id].FindIndex((m) => task.Message.Id == m.Id));
messagesList = messages[task.Conversation.Id].AsEnumerable().Reverse().Skip(toRemove).Take(task.GetCount).Reverse().ToList();
}
else
{
messagesList = new List <Message>();
}
MessagingCenter.Send(new MessagingTask(messages: messagesList, users: users, conversation: task.Conversation), MessagingTask.LocalMessagesLimited);
});
// Get all conversations
MessagingCenter.Subscribe <MessagingTask>(this, MessagingTask.GetConversations, (task) =>
{
MessagingCenter.Send(new MessagingTask(conversations: conversations, users: users), MessagingTask.LocalConversations);
});
//Sender result
messageSender.Result += (status, message) =>
{
//If failed stop
if (status == MessageSendStatus.InvalidPrivateKey)
{
if (LocalUserManager.LocalUser != null)
{
messageGetter.PrivateKey = LocalUserManager.LocalUser.PrivateKey;
}
else
{
messageGetter.Result = null;
messageGetter.StopGetting();
messageSender.Result = null;
messageSender.StopSending();
}
}
};
//Enqueue message to sender
MessagingCenter.Subscribe <MessagingTask>(this, MessagingTask.AddMessageToQueue, (task) =>
{
messageSender.AddMessageToQueue(task.Message);
});
//Stop the service
MessagingCenter.Subscribe <MessagingTask>(this, MessagingTask.Stop, (task) =>
{
Device.BeginInvokeOnMainThread(() =>
{
messageGetter.Result = null;
messageGetter.StopGetting();
messageSender.Result = null;
messageSender.StopSending();
Stop();
});
});
new Thread(() =>
{
var temp = users.ToDictionary(entry => entry.Key,
entry => entry.Value);
LoadData();
Device.BeginInvokeOnMainThread(() =>
{
MessagingCenter.Send(new MessagingTask(messagesDict: messages, users: users), MessagingTask.NewMessages);
});
foreach (var entry in temp)
{
var getter = UserSystemManager.UserGetter();
if (getter != null)
{
getter.Result += (status, user) =>
{
if (status == UserGetStatus.Success)
{
users[user.Username] = user;
}
};
getter.Get(entry.Value.Username);
}
}
conversations.ForEach(conv =>
{
messageGetter.TimeStamp = Math.Max(conv.LastActivity, messageGetter.TimeStamp);
});
messageGetter.GetUsers = true;
if (!stoppedSelf)
{
messageGetter.StartGetting();
messageSender.StartSending();
}
Device.BeginInvokeOnMainThread(() =>
{
MessagingCenter.Send(new MessagingTask(), MessagingTask.Started);
});
Console.WriteLine("SERVICE STARTED");
}).Start();
; return(StartCommandResult.Sticky);
}
