public HistoryCallEventViewModel(VATRPCallEvent callEvent, VATRPContact contact)
: this()
{
this._callEvent = callEvent;
this._backColor = callEvent.Status == VATRPHistoryEvent.StatusType.Missed ? new SolidColorBrush(Color.FromArgb(255, 0xFE, 0xCD, 0xCD)) : new SolidColorBrush(Color.FromArgb(255, 0xE9, 0xEF, 0xE9));
UpdateContact(contact);
LoadCallStateIndicator();
DateTime callTime =
VATRP.Core.Model.Utils.Time.ConvertUtcTimeToLocalTime(
VATRP.Core.Model.Utils.Time.ConvertDateTimeToLong(callEvent.StartTime) / 1000);
string dateFormat = "d/MM h:mm tt";
var diffTime = DateTime.Now - callTime;
if (diffTime.Days == 0)
{
dateFormat = "h:mm tt";
}
else if (diffTime.Days < 8)
{
dateFormat = "ddd h:mm tt";
}
else if (diffTime.Days > 365)
{
dateFormat = "dd/MM/yy h:mm tt"; //Added YY in date format by MK on dated 02-NOV-2016 TO DISPLAY YEAR IN CALL DATE
}
CallDate = callTime.ToString(dateFormat);
}
internal void UpdateLoggedinContact()
{
if (App.CurrentAccount == null || !App.CurrentAccount.Username.NotBlank())
{
return;
}
var contactAddress = string.Format("{0}@{1}", App.CurrentAccount.Username,
App.CurrentAccount.ProxyHostname);
VATRPContact contact = this.ContactService.FindLoggedInContact();
bool addLogedInContact = true;
if (contact != null)
{
if (contact.SipUsername == contactAddress)
{
contact.IsLoggedIn = false;
addLogedInContact = false;
}
}
if (addLogedInContact)
{
var contactID = new ContactID(contactAddress, IntPtr.Zero);
contact = new VATRPContact(contactID)
{
IsLoggedIn = true,
Fullname = App.CurrentAccount.Username,
DisplayName = App.CurrentAccount.DisplayName,
RegistrationName =
string.Format("sip:{0}@{1}", App.CurrentAccount.Username, App.CurrentAccount.ProxyHostname)
};
contact.Initials = contact.Fullname.Substring(0, 1).ToUpper();
this.ContactService.AddContact(contact, string.Empty);
}
}
private void OnConversationClosed(object sender, ConversationEventArgs e)
{
if (ServiceManager.Instance.Dispatcher.Thread != Thread.CurrentThread)
{
ServiceManager.Instance.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
new EventHandler <ConversationEventArgs>(OnConversationClosed), sender, new object[] { e });
return;
}
VATRPContact contact = e.Conversation.Contact;
if (contact != null)
{
if (ChatViewContact != null && ChatViewContact.Contact == e.Conversation.Contact)
{
ChatViewContact = null;
}
RemoveContact(contact);
if (this.Chat == e.Conversation)
{
this._chat = null;
MessagesListView = null;
}
OnPropertyChanged("Chat");
}
}
internal bool CheckReceiverContact()
{
//****************************************************************************************
// Check Chat message receiver contact. it should not be null.
//*****************************************************************************************
var receiver = string.Empty;
if (ReceiverAddress != null)
{
receiver = ReceiverAddress.Trim();
}
if (ChatViewContact != null && receiver == ChatViewContact.Contact.RegistrationName)
{
return(true);
}
VATRPContact contact = _chatsManager.FindContact(new ContactID(receiver, IntPtr.Zero));
if (contact == null)
{
string un, host, dn;
int port;
if (!VATRPCall.ParseSipAddress(receiver, out un,
out host, out port))
{
un = "";
}
if (!un.NotBlank())
{
return(false);
}
if (string.IsNullOrEmpty(host))
{
host = App.CurrentAccount.ProxyHostname;
}
var contactAddress = string.Format("{0}@{1}", un, host);
var contactID = new ContactID(contactAddress, IntPtr.Zero);
contact = new VATRPContact(contactID)
{
DisplayName = un,
Fullname = un,
SipUsername = un,
RegistrationName = contactAddress
};
_contactsManager.AddContact(contact, "");
}
SetActiveChatContact(contact, IntPtr.Zero);
if (ReceiverAddress != contact.RegistrationName)
{
ReceiverAddress = contact.RegistrationName;
}
return(true);
}
public ContactViewModel(VATRPContact contact)
{
//****************************************************************************************************
// Setting the Contact Status color. If online then Green else Grey
//****************************************************************************************************
this._viewModelID = ++IdIncremental;
this._contact = contact;
this.backColor = contact.Status != UserStatus.Offline ? new SolidColorBrush(Color.FromArgb(255, 115, 215, 120)) : new SolidColorBrush(Color.FromArgb(255, 200, 200, 200));
this._contact.PropertyChanged += _contact_PropertyChanged;
LoadContactAvatar();
}
private object FindContact(VATRPContact contact)
{
lock (this.Contacts)
{
foreach (var c in Contacts)
{
if (c.Contact == contact)
{
return(contact);
}
}
}
return(null);
}
internal void DeclineCall(CallViewModel viewModel, string message)
{
//***********************************************************************************************************************************
// Call Declined, Message will contain a message like I am in meeting which was selected when call is declined.
//***********************************************************************************************************************************
lock (CallsViewModelList)
{
if (FindCallViewModel(viewModel))
{
LOG.Info(String.Format("Declining call for {0}. {1}", viewModel.CallerInfo,
viewModel.ActiveCall.NativeCallPtr));
var contactID = new ContactID(
string.Format("{0}@{1}", viewModel.ActiveCall.RemoteParty.Username,
viewModel.ActiveCall.RemoteParty.HostAddress), IntPtr.Zero);
var contact = ServiceManager.Instance.ContactService.FindContact(contactID);
if (contact == null)
{
contact = new VATRPContact(contactID)
{
Fullname = viewModel.ActiveCall.RemoteParty.Username,
DisplayName = viewModel.ActiveCall.RemoteParty.Username,
SipUsername = viewModel.ActiveCall.RemoteParty.Username,
RegistrationName = contactID.ID
};
ServiceManager.Instance.ContactService.AddContact(contact, string.Empty);
}
viewModel.DeclineCall(false);
try
{
_linphoneService.DeclineCall(viewModel.ActiveCall.NativeCallPtr);
}
catch (Exception ex)
{
ServiceManager.LogError("DeclineCall", ex);
}
if (message.NotBlank())
{
if (_simpleMessageViewModel != null)
{
_simpleMessageViewModel.SetActiveChatContact(contact, IntPtr.Zero);
_simpleMessageViewModel.SendSimpleMessage(string.Format("{0}{1}", VATRPChatMessage.DECLINE_PREFIX, message));
}
}
}
}
}
internal void UpdateContact(VATRPContact newContact)
{
if (_contact != null && newContact == null)
{
_contact.PropertyChanged -= OnContactPropertyChanged;
}
_contact = newContact;
_callEvent.Contact = newContact;
if (_contact != null)
{
_contact.PropertyChanged += OnContactPropertyChanged;
if (_contact.IsLinphoneContact)
{
_allowAddContact = false;
}
}
LoadContactAvatar();
}
private void AddContact(VATRPContact contact, bool refreshNow = false)
{
if (!contact.SipUsername.NotBlank() || !contact.IsLinphoneContact)
{
return;
}
if (FindContact(contact) != null)
{
return;
}
lock (this.Contacts)
{
contact.PropertyChanged += OnContactPropertyChanged;
Contacts.Add(new ContactViewModel(contact));
}
if (refreshNow)
{
ContactsListView.Refresh();
}
}
internal void DeclineCall(CallViewModel viewModel, string message)
{
lock (CallsViewModelList)
{
if (FindCallViewModel(viewModel))
{
LOG.Info(String.Format("Declining call for {0}. {1}", viewModel.CallerInfo,
viewModel.ActiveCall.NativeCallPtr));
var contactID = new ContactID(
string.Format("{0}@{1}", viewModel.ActiveCall.RemoteParty.Username,
viewModel.ActiveCall.RemoteParty.HostAddress), IntPtr.Zero);
var contact = ServiceManager.Instance.ContactService.FindContact(contactID);
if (contact == null)
{
contact = new VATRPContact(contactID)
{
Fullname = viewModel.ActiveCall.RemoteParty.Username,
DisplayName = viewModel.ActiveCall.RemoteParty.Username,
SipUsername = viewModel.ActiveCall.RemoteParty.Username,
RegistrationName = contactID.ID
};
ServiceManager.Instance.ContactService.AddContact(contact, string.Empty);
}
viewModel.DeclineCall(false);
try
{
_linphoneService.DeclineCall(viewModel.ActiveCall.NativeCallPtr);
}
catch (Exception ex)
{
ServiceManager.LogError("DeclineCall", ex);
}
if (message.NotBlank())
{
if (_simpleMessageViewModel != null)
{
_simpleMessageViewModel.SetActiveChatContact(contact, IntPtr.Zero);
_simpleMessageViewModel.SendMessage(string.Format("{0}{1}", VATRPChatMessage.DECLINE_PREFIX, message));
}
}
}
}
}
public void SetActiveChatContact(VATRPContact contact, IntPtr callPtr)
{
if (contact == null)
return;
if (Chat != null && Chat.Contact == contact)
{
Chat.Contact.UnreadMsgCount = 0;
Chat.UnreadMsgCount = 0;
ChangeUnreadCounter();
_chatsManager.ActivateChat(Chat);
return;
}
Console.WriteLine("SetActiveChat " + contact.Fullname);
this._chat = _chatsManager.GetChat(contact);
var contactVM = FindContactViewModel(contact);
if (contactVM == null)
{
contactVM = new ContactViewModel(contact);
this.Contacts.Add(contactVM);
}
if (_contactViewModel != null && _contactViewModel.Contact != contactVM.Contact)
{
_contactViewModel.IsSelected = false;
}
_contactViewModel = contactVM;
if (Chat != null)
{
Chat.CallPtr = callPtr;
if (Chat.Contact != null)
{
Chat.Contact.UnreadMsgCount = 0;
this.Chat.Contact.PropertyChanged += this.Contact_PropertyChanged;
}
Chat.CharsCountInBubble = 0;
Chat.UnreadMsgCount = 0;
ChangeUnreadCounter();
_chatsManager.ActivateChat(Chat);
if (App.CurrentAccount != null)
{
Chat.MessageFont = App.CurrentAccount.RTTFontFamily;
}
}
_contactViewModel.IsSelected = true;
IsMessagesLoaded = false;
if ( Messages != null)
{
this.MessagesListView = CollectionViewSource.GetDefaultView(this.Messages);
this.MessagesListView.SortDescriptions.Add(new SortDescription("MessageTime",
ListSortDirection.Ascending));
}
OnPropertyChanged("Chat");
if (MessagesListView != null)
MessagesListView.Refresh();
if (ConversationUpdated != null)
ConversationUpdated(this, EventArgs.Empty);
}
internal void UpdateLoggedinContact()
{
if (App.CurrentAccount == null || !App.CurrentAccount.Username.NotBlank())
return;
var contactAddress = string.Format("{0}@{1}", App.CurrentAccount.Username,
App.CurrentAccount.ProxyHostname);
VATRPContact contact = this.ContactService.FindLoggedInContact();
bool addLogedInContact = true;
if (contact != null)
{
if (contact.SipUsername == contactAddress)
{
contact.IsLoggedIn = false;
addLogedInContact = false;
}
}
if (addLogedInContact)
{
var contactID = new ContactID(contactAddress, IntPtr.Zero);
contact = new VATRPContact(contactID)
{
IsLoggedIn = true,
Fullname = App.CurrentAccount.Username,
DisplayName = App.CurrentAccount.DisplayName,
RegistrationName =
string.Format("sip:{0}@{1}", App.CurrentAccount.Username, App.CurrentAccount.ProxyHostname)
};
contact.Initials = contact.Fullname.Substring(0, 1).ToUpper();
this.ContactService.AddContact(contact, string.Empty);
}
}
private void LoadLinphoneContacts()
{
if (_manager.LinphoneService.LinphoneCore == IntPtr.Zero)
return;
IntPtr contactsPtr =
LinphoneAPI.linphone_core_get_friend_list(_manager.LinphoneService.LinphoneCore);
if (contactsPtr != IntPtr.Zero)
{
MSList curStruct;
do
{
curStruct.next = IntPtr.Zero;
curStruct.prev = IntPtr.Zero;
curStruct.data = IntPtr.Zero;
curStruct = (MSList)Marshal.PtrToStructure(contactsPtr, typeof(MSList));
if (curStruct.data != IntPtr.Zero)
{
IntPtr addressPtr = LinphoneAPI.linphone_friend_get_address(curStruct.data);
if (addressPtr == IntPtr.Zero)
continue;
string dn = "";
IntPtr tmpPtr = LinphoneAPI.linphone_address_get_display_name(addressPtr);
if (tmpPtr != IntPtr.Zero)
{
dn = Marshal.PtrToStringAnsi(tmpPtr);
}
string un = "";
tmpPtr = LinphoneAPI.linphone_address_get_username(addressPtr);
if (tmpPtr != IntPtr.Zero)
{
un = Marshal.PtrToStringAnsi(tmpPtr);
}
string host = "";
tmpPtr = LinphoneAPI.linphone_address_get_domain(addressPtr);
if (tmpPtr != IntPtr.Zero)
{
host = Marshal.PtrToStringAnsi(tmpPtr);
}
string refKey = "";
tmpPtr = LinphoneAPI.linphone_friend_get_ref_key(curStruct.data);
if (tmpPtr != IntPtr.Zero)
refKey = Marshal.PtrToStringAnsi(tmpPtr);
if (string.IsNullOrEmpty(refKey))
{
// generate refkey
refKey = Guid.NewGuid().ToString();
LinphoneAPI.linphone_friend_set_ref_key(curStruct.data, refKey);
}
int port = LinphoneAPI.linphone_address_get_port(addressPtr);
if (!string.IsNullOrWhiteSpace(un))
{
var cfgSipaddress = port == 0 ? string.Format("{0}@{1}", un, host):
string.Format("{0}@{1}:{2}", un, host, port);
VATRPContact contact = new VATRPContact(new ContactID(cfgSipaddress, IntPtr.Zero))
{
DisplayName = dn,
Fullname = dn.NotBlank() ? dn : un,
Gender = "male",
SipUsername = un,
RegistrationName = cfgSipaddress,
IsLinphoneContact = true,
LinphoneRefKey = refKey
};
UpdateAvatar(contact);
Contacts.Add(contact);
}
}
contactsPtr = curStruct.next;
} while (curStruct.next != IntPtr.Zero);
}
LoadContactsOptions();
if ( ContactsLoadCompleted != null)
ContactsLoadCompleted(this, EventArgs.Empty);
}
private void UpdateAvatar(VATRPContact contact)
{
var supportedFormats = new[] {"jpg", "jpeg", "png", "bmp"};
for (var i = 0; i < supportedFormats.Length; i++)
{
var avatar = _manager.BuildDataPath(string.Format("{0}.{1}", contact.ID, supportedFormats[i]));
if (File.Exists(avatar))
{
contact.Avatar = avatar;
return;
}
}
}
public void EditLinphoneContact(VATRPContact contact, string newname, string newsipassdress)
{
if (_manager.LinphoneService.LinphoneCore == IntPtr.Zero)
return;
IntPtr friendList = LinphoneAPI.linphone_core_get_default_friend_list(_manager.LinphoneService.LinphoneCore);
if (friendList == IntPtr.Zero)
return;
IntPtr friendPtr = LinphoneAPI.linphone_friend_list_find_friend_by_ref_key(friendList,
contact.LinphoneRefKey);
if (friendPtr == IntPtr.Zero)
return;
var newfqdn = string.Format("sip:{0}", newsipassdress);
IntPtr addressPtr = LinphoneAPI.linphone_core_create_address(
_manager.LinphoneService.LinphoneCore, string.Format("{0} <{1}>", newname, newfqdn));
if (addressPtr != IntPtr.Zero)
{
LinphoneAPI.linphone_friend_edit(friendPtr);
LinphoneAPI.linphone_friend_set_name(friendPtr, newname);
LinphoneAPI.linphone_friend_set_address(friendPtr, addressPtr);
LinphoneAPI.linphone_friend_enable_subscribes(friendPtr, false);
LinphoneAPI.linphone_friend_set_inc_subscribe_policy(friendPtr, 1);
LinphoneAPI.linphone_friend_done(friendPtr);
string un = "";
IntPtr unPtr = LinphoneAPI.linphone_address_get_username(addressPtr);
if (unPtr != IntPtr.Zero)
{
un = Marshal.PtrToStringAnsi(unPtr);
}
contact.ID = newsipassdress;
contact.DisplayName = newname;
contact.Fullname = newname;
contact.SipUsername = un;
contact.RegistrationName = newsipassdress;
}
UpdateAvatar(contact);
UpdateContactDbId(contact);
if (ContactsChanged != null)
ContactsChanged(this, new ContactEventArgs(new ContactID(contact)));
}
private void OnChatMessageReceived(IntPtr chatPtr, IntPtr callChatPtr, string remoteUser, VATRPChatMessage chatMessage)
{
string dn, un, host;
int port;
if (callChatPtr == chatPtr /*&& RttEnabled*/)
{
return;
}
System.Windows.Threading.Dispatcher dispatcher = null;
try
{
dispatcher = this._serviceManager.Dispatcher;
}
catch (NullReferenceException)
{
return;
}
if (dispatcher != null)
dispatcher.BeginInvoke((Action) delegate()
{
if (!VATRPCall.ParseSipAddressEx(remoteUser, out dn, out un,
out host, out port))
un = "";
if (!un.NotBlank())
return;
var contactAddress = string.Format("{0}@{1}", un, host);
var contactID = new ContactID(contactAddress, IntPtr.Zero);
VATRPContact contact = FindContact(contactID);
if (contact == null)
{
contact = new VATRPContact(contactID)
{
DisplayName = dn,
Fullname = dn.NotBlank() ? dn : un,
SipUsername = un,
RegistrationName = contactAddress
};
_contactSvc.AddContact(contact, "");
Contacts.Add(contact);
if (ContactAdded != null)
ContactAdded(this, new ContactEventArgs(new ContactID(contact)));
}
VATRPChat chat = GetChat(contact);
chat.NativePtr = chatPtr;
if (chat.CheckMessage(chatMessage))
{
chat.UnreadMsgCount++;
if (!chat.IsSelected)
contact.UnreadMsgCount++;
chatMessage.IsRTTMessage = false;
chatMessage.IsIncompleteMessage = false;
chatMessage.Chat = chat;
if (chatMessage.Content.StartsWith(VATRPChatMessage.DECLINE_PREFIX))
{
chatMessage.Content = chatMessage.Content.Substring(VATRPChatMessage.DECLINE_PREFIX.Length);
chatMessage.IsDeclineMessage = true;
if (ConversationDeclineMessageReceived != null)
{
var declineArgs = new DeclineMessageArgs(chatMessage.Content) { Sender = contact };
ConversationDeclineMessageReceived(this, declineArgs);
}
}
chat.AddMessage(chatMessage, false);
chat.UpdateLastMessage(false);
OnConversationUnReadStateChanged(chat);
this.OnConversationUpdated(chat, true);
}
});
}
private object FindContact(VATRPContact contact)
{
lock (this.Contacts)
{
foreach (var c in Contacts)
{
if (c.Contact == contact)
{
return contact;
}
}
}
return null;
}
private void AddContact(VATRPContact contact, bool refreshNow = false)
{
if (!contact.SipUsername.NotBlank() || !contact.IsLinphoneContact)
return;
if (FindContact(contact) != null)
return;
lock (this.Contacts)
{
contact.PropertyChanged += OnContactPropertyChanged;
Contacts.Add(new ContactViewModel(contact));
}
if (refreshNow)
ContactsListView.Refresh();
}
public VATRPChat CreateChat(VATRPContact contact, string dialogId)
{
if (contact == null)
{
return null;
}
VATRPChat chatRoom = new VATRPChat(contact, dialogId);
var loggedContact = _contactSvc.FindLoggedInContact();
if (loggedContact != null)
chatRoom.AddContact(loggedContact);
_chatItems.InsertToTop<VATRPChat>(chatRoom);
this.OnNewConversationCreated(chatRoom);
return chatRoom;
}
public VATRPChat CreateChat(VATRPContact contact)
{
if (contact == null)
{
return null;
}
return this.CreateChat(contact, string.Empty);
}
private void UpdateContactStatusInChats(VATRPContact contact)
{
foreach (VATRPChat chat in this._chatItems)
{
for (int i = 0; i < chat.Contacts.Count; i++)
{
if (contact.Equals(chat.Contacts[i]))
{
chat.Contacts[i].Status = contact.Status;
}
}
}
}
public void SetActiveChatContact(VATRPContact contact, IntPtr callPtr)
{
if (contact == null)
{
return;
}
if (Chat != null && Chat.Contact == contact)
{
Chat.Contact.UnreadMsgCount = 0;
Chat.UnreadMsgCount = 0;
ChangeUnreadCounter();
_chatsManager.ActivateChat(Chat);
return;
}
this._chat = _chatsManager.GetChat(contact, false);
var contactVM = FindContactViewModel(contact);
if (contactVM == null)
{
contactVM = new ContactViewModel(contact);
this.Contacts.Add(contactVM);
}
if (ChatViewContact != null && ChatViewContact.Contact != contactVM.Contact)
{
ChatViewContact.IsSelected = false;
}
ChatViewContact = contactVM;
if (Chat != null)
{
Chat.CallPtr = callPtr;
if (Chat.Contact != null)
{
Chat.Contact.UnreadMsgCount = 0;
this.Chat.Contact.PropertyChanged += this.Contact_PropertyChanged;
}
Chat.CharsCountInBubble = 0;
Chat.UnreadMsgCount = 0;
ChangeUnreadCounter();
_chatsManager.ActivateChat(Chat);
if (App.CurrentAccount != null)
{
Chat.MessageFont = App.CurrentAccount.RTTFontFamily;
}
}
ChatViewContact.IsSelected = true;
IsMessagesLoaded = false;
this.MessagesListView = CollectionViewSource.GetDefaultView(this.Messages);
this.MessagesListView.SortDescriptions.Add(new SortDescription("MessageTime",
ListSortDirection.Ascending));
OnPropertyChanged("Chat");
try
{
if (MessagesListView != null && this.Messages != null)
{
MessagesListView.Refresh();
}
}
catch (Exception)
{
}
if (ConversationUpdated != null)
{
ConversationUpdated(this, EventArgs.Empty);
}
}
internal bool SearchContactIfExistOrCreateNew(ContactID contactID, out VATRPContact contact)
{
bool flag = false;
contact = this.FindContact(contactID);
if (contact == null)
{
flag = true;
contact = new VATRPContact(contactID);
}
return flag;
}
internal bool CheckReceiverContact()
{
var receiver = string.Empty;
if (ReceiverAddress != null)
{
receiver = ReceiverAddress.Trim();
}
if (Contact != null && receiver == Contact.Contact.RegistrationName)
return true;
VATRPContact contact = _chatsManager.FindContact(new ContactID(receiver, IntPtr.Zero));
if (contact == null)
{
string un, host, dn;
int port;
if (!VATRPCall.ParseSipAddress(receiver, out un,
out host, out port))
un = "";
if (!un.NotBlank())
return false;
if (string.IsNullOrEmpty(host))
host = App.CurrentAccount.ProxyHostname;
var contactAddress = string.Format("{0}@{1}", un, host);
var contactID = new ContactID(contactAddress, IntPtr.Zero);
contact = new VATRPContact(contactID)
{
DisplayName = un,
Fullname = un,
SipUsername = un,
RegistrationName = contactAddress
};
_contactsManager.AddContact(contact, "");
}
SetActiveChatContact(contact, IntPtr.Zero);
if ( ReceiverAddress != contact.RegistrationName )
ReceiverAddress = contact.RegistrationName;
return true;
}
internal ContactStatusChangedEventArgs(VATRPContact _contact, UserStatus oldStatus)
{
this.OldStatus = oldStatus;
this.contact = _contact;
}
public VATRPChat FindChat(VATRPContact contact)
{
if (contact == null)
{
return null;
}
return this.FindChat(new ContactID(contact.ID, contact.NativePtr));
}
public void AddLinphoneContact(string name, string username, string address)
{
if (_manager.LinphoneService.LinphoneCore == IntPtr.Zero)
return;
var sipAddress = address.TrimSipPrefix();
var fqdn = string.Format("{0} <sip:{1}>", name, sipAddress);
IntPtr friendPtr = LinphoneAPI.linphone_friend_new_with_address(fqdn);
if (friendPtr != IntPtr.Zero)
{
IntPtr friendList =
LinphoneAPI.linphone_core_get_default_friend_list(_manager.LinphoneService.LinphoneCore);
LinphoneAPI.linphone_friend_set_name(friendPtr, name);
LinphoneAPI.linphone_friend_enable_subscribes(friendPtr, false);
LinphoneAPI.linphone_friend_set_inc_subscribe_policy(friendPtr, 1);
LinphoneAPI.linphone_friend_list_add_friend(friendList, friendPtr);
var refKey = Guid.NewGuid().ToString();
LinphoneAPI.linphone_friend_set_ref_key(friendPtr, refKey);
var contactID = new ContactID(sipAddress, IntPtr.Zero);
VATRPContact contact = FindContact(contactID);
if (contact == null)
{
contact = new VATRPContact(new ContactID(sipAddress, IntPtr.Zero))
{
DisplayName = name,
Fullname = name,
Gender = "male",
SipUsername = username,
RegistrationName = sipAddress,
IsLinphoneContact = true,
LinphoneRefKey = refKey
};
Contacts.Add(contact);
}
else
{
contact.DisplayName = name;
contact.Fullname = name;
contact.IsLinphoneContact = true;
contact.SipUsername = username;
contact.LinphoneRefKey = refKey;
}
UpdateAvatar(contact);
UpdateContactDbId(contact);
if (ContactAdded != null)
{
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
{
ContactAdded(this, new ContactEventArgs(new ContactID(contact)));
}));
}
}
}
public void AddContact(VATRPContact contact, string group)
{
// update avatar
UpdateAvatar(contact);
Contacts.Add(contact);
if (ContactAdded != null)
ContactAdded(this, new ContactEventArgs(new ContactID(contact)));
if (contact.IsLoggedIn && LoggedInContactUpdated != null)
{
LoggedInContactUpdated(this, new ContactEventArgs(new ContactID(contact)));
}
}
public VATRPChat GetChat(VATRPContact contact)
{
VATRPChat chat = this.FindChat(contact);
if (chat == null)
{
chat = this.AddChat(contact, string.Empty);
this.Contacts.Add(contact);
if (ContactAdded != null)
ContactAdded(this, new ContactEventArgs(new ContactID(contact)));
}
return chat;
}
public void DeleteLinphoneContact(VATRPContact contact)
{
if (_manager.LinphoneService.LinphoneCore == IntPtr.Zero)
return;
IntPtr friendList = LinphoneAPI.linphone_core_get_default_friend_list(_manager.LinphoneService.LinphoneCore);
if (friendList != IntPtr.Zero)
{
IntPtr friendPtr = LinphoneAPI.linphone_friend_list_find_friend_by_ref_key(friendList,
contact.LinphoneRefKey);
if (friendPtr == IntPtr.Zero)
return;
if (friendList != IntPtr.Zero)
LinphoneAPI.linphone_friend_list_remove_friend(friendList, friendPtr);
RemoveFavoriteOption(contact);
try
{
if (contact.Avatar.NotBlank() && File.Exists(contact.Avatar))
{
File.Delete(contact.Avatar);
}
}
catch (Exception ex)
{
Debug.WriteLine("failed to remove file: " + ex.Message);
}
RemoveContact(contact.ID, true);
}
}
internal void SetStatusForMessage(VATRPContact contact, string msgId, LinphoneChatMessageState status)
{
if (msgId.NotBlank())
{
if (contact != null)
{
VATRPChat chat = this.FindChat(contact);
if ((chat != null) && msgId.NotBlank())
{
foreach (VATRPChatMessage message in chat.Messages)
{
if (message.ID == msgId)
{
if (status > message.Status)
{
message.Status = status;
}
break;
}
}
}
}
else
{
using (IEnumerator<VATRPChat> enumerator2 = this._chatItems.GetEnumerator())
{
while (enumerator2.MoveNext())
{
foreach (VATRPChatMessage message2 in enumerator2.Current.Messages)
{
if (message2.ID == msgId)
{
if (status > message2.Status)
{
message2.Status = status;
}
return;
}
}
}
}
}
}
}
public void UpdateFavoriteOption(VATRPContact contact)
{
if (contact.DbID == 0)
return;
if (editing)
return;
editing = true;
try
{
var connectionString = string.Format("data source={0}", _manager.LinphoneService.ContactsDbPath);
using (var dbConnection = new SQLiteConnection(connectionString))
{
dbConnection.Open();
using (
var cmd = new SQLiteCommand(dbConnection)
{
CommandText = @"INSERT OR REPLACE INTO friend_options (id, is_favorite) VALUES ( ?, ?)"
})
{
var idParam = new SQLiteParameter(DbType.Int32) {Value = contact.DbID};
cmd.Parameters.Add(idParam);
var favParam = new SQLiteParameter(DbType.Int32) {Value = contact.IsFavorite ? 1 : 0};
cmd.Parameters.Add(favParam);
cmd.ExecuteNonQuery();
}
dbConnection.Close();
}
}
catch (SQLiteException ex)
{
Debug.WriteLine("Sqlite error: " + ex.ToString());
}
finally
{
editing = false;
}
}
internal void SetStatusLastMessageInActiveChat(VATRPContact contact, string msgText, LinphoneChatMessageState status)
{
if ((msgText != null) && (contact != null))
{
VATRPChat chat = this.FindChat(contact);
if ((((chat != null) && ((chat.Messages != null) && (chat.Messages.Count != 0))) &&
msgText.Equals(chat.Messages[chat.Messages.Count - 1])) &&
(status > chat.Messages[chat.Messages.Count - 1].Status))
{
chat.Messages[chat.Messages.Count - 1].Status = status;
}
}
}
private void LinphoneCardDavContactCreated(CardDavContactEventArgs args)
{
if (args.NewContactPtr == IntPtr.Zero) return;
IntPtr addressPtr = LinphoneAPI.linphone_friend_get_address(args.NewContactPtr);
if (addressPtr == IntPtr.Zero)
return;
string dn = "";
IntPtr tmpPtr = LinphoneAPI.linphone_address_get_display_name(addressPtr);
if (tmpPtr != IntPtr.Zero)
{
dn = Marshal.PtrToStringAnsi(tmpPtr);
}
string un = "";
tmpPtr = LinphoneAPI.linphone_address_get_username(addressPtr);
if (tmpPtr != IntPtr.Zero)
{
un = Marshal.PtrToStringAnsi(tmpPtr);
}
string host = "";
tmpPtr = LinphoneAPI.linphone_address_get_domain(addressPtr);
if (tmpPtr != IntPtr.Zero)
{
host = Marshal.PtrToStringAnsi(tmpPtr);
}
int port = LinphoneAPI.linphone_address_get_port(addressPtr);
if (string.IsNullOrWhiteSpace(un)) return;
var cfgSipaddress = port == 0 ? string.Format("{0}@{1}", un, host) :
string.Format("{0}@{1}:{2}", un, host, port);
var refKey = "";
IntPtr refKeyPtr = LinphoneAPI.linphone_friend_get_ref_key(args.NewContactPtr);
if (refKeyPtr != IntPtr.Zero)
refKey = Marshal.PtrToStringAnsi(refKeyPtr);
if (String.IsNullOrEmpty(refKey))
{
refKey = Guid.NewGuid().ToString();
LinphoneAPI.linphone_friend_set_ref_key(args.NewContactPtr, refKey);
}
VATRPContact contact = new VATRPContact(new ContactID(cfgSipaddress, IntPtr.Zero))
{
DisplayName = dn,
Fullname = dn.NotBlank() ? dn : un,
Gender = "male",
SipUsername = un,
RegistrationName = cfgSipaddress,
IsLinphoneContact = true,
LinphoneRefKey = refKey
};
AddContact(contact, string.Empty);
}
private VATRPChat AddChat(VATRPContact contact, string dialogId)
{
VATRPChat item = null;
if (contact != null)
{
item = this.FindChat(contact);
if (item == null)
{
item = this.CreateChat(contact, dialogId);
}
}
return item;
}
private void RemoveFavoriteOption(VATRPContact contact)
{
if (contact.DbID == 0)
return;
if (editing)
return;
editing = true;
try
{
var connectionString = string.Format("data source={0}", _manager.LinphoneService.ContactsDbPath);
using (var dbConnection = new SQLiteConnection(connectionString))
{
dbConnection.Open();
using (
var cmd = new SQLiteCommand(dbConnection)
{
CommandText = @"DELETE FROM friend_options WHERE id = ?"
})
{
var idParam = new SQLiteParameter(DbType.Int32) {Value = contact.DbID};
cmd.Parameters.Add(idParam);
cmd.ExecuteNonQuery();
}
dbConnection.Close();
}
}
catch (SQLiteException ex)
{
Debug.WriteLine("Sqlite error: " + ex.ToString());
}
finally
{
editing = false;
}
}
private void LoadLinphoneChatEvents()
{
if (_chatItems == null)
_chatItems = new ObservableCollection<VATRPChat>();
if (_linphoneSvc.LinphoneCore == IntPtr.Zero)
return;
IntPtr chatRoomPtr = LinphoneAPI.linphone_core_get_chat_rooms(_linphoneSvc.LinphoneCore);
if (chatRoomPtr != IntPtr.Zero)
{
MSList msChatRoomList;
do
{
msChatRoomList.next = IntPtr.Zero;
msChatRoomList.prev = IntPtr.Zero;
msChatRoomList.data = IntPtr.Zero;
msChatRoomList = (MSList)Marshal.PtrToStructure(chatRoomPtr, typeof(MSList));
if (msChatRoomList.data != IntPtr.Zero)
{
IntPtr tmpPtr = LinphoneAPI.linphone_chat_room_get_peer_address(msChatRoomList.data);
if (tmpPtr != IntPtr.Zero)
{
tmpPtr = LinphoneAPI.linphone_address_as_string(tmpPtr);
if (tmpPtr != IntPtr.Zero)
{
var remoteParty = LinphoneAPI.PtrToStringUtf8(tmpPtr);
LinphoneAPI.ortp_free(tmpPtr);
string dn, un, host;
int port;
if (
!VATRPCall.ParseSipAddressEx( remoteParty, out dn, out un,
out host, out port))
un = "";
if (un.NotBlank())
{
var contactAddress = string.Format("{0}@{1}", un, host);
var contactId = new ContactID(contactAddress, IntPtr.Zero);
VATRPContact contact = _contactSvc.FindContact(contactId);
if (contact == null)
{
contact = new VATRPContact(contactId)
{
DisplayName = dn,
Fullname = un,
SipUsername = un,
RegistrationName = contactAddress
};
_contactSvc.AddContact(contact, string.Empty);
}
var chat = this.AddChat(contact, string.Empty);
chat.NativePtr = msChatRoomList.data;
LoadMessages(chat, chat.NativePtr);
OnConversationUpdated(chat, true);
}
}
}
}
chatRoomPtr = msChatRoomList.next;
} while (msChatRoomList.next != IntPtr.Zero);
}
if (ServiceStarted != null)
ServiceStarted(this, EventArgs.Empty);
}
private void UpdateContactDbId(VATRPContact contact)
{
if (editing)
return;
editing = true;
try
{
var connectionString = string.Format("data source={0}", _manager.LinphoneService.ContactsDbPath);
using (var dbConnection = new SQLiteConnection(connectionString))
{
dbConnection.Open();
using (
var cmd = new SQLiteCommand(dbConnection)
{
CommandText = @"SELECT id FROM friends WHERE sip_uri = ?"
})
{
var sipUri = string.Format(@"""{0}"" <sip:{1}>", contact.DisplayName, contact.ID);
var uriParam = new SQLiteParameter(DbType.AnsiString) {Value = sipUri};
cmd.Parameters.Add(uriParam);
var dbReader = cmd.ExecuteReader();
if (dbReader.Read())
{
contact.DbID = dbReader.GetInt32(0);
}
}
dbConnection.Close();
}
}
catch (SQLiteException ex)
{
Debug.WriteLine("Sqlite error: " + ex.ToString());
}
finally
{
editing = false;
}
}
private void LoadMessages(VATRPChat chat, IntPtr chatRoomPtr)
{
IntPtr msgListPtr = LinphoneAPI.linphone_chat_room_get_history(chatRoomPtr, 0);
if (msgListPtr != IntPtr.Zero)
{
MSList msMessagePtr;
var loggedInContact = _contactSvc.FindLoggedInContact();
if (loggedInContact == null)
return;
do
{
msMessagePtr.next = IntPtr.Zero;
msMessagePtr.prev = IntPtr.Zero;
msMessagePtr.data = IntPtr.Zero;
msMessagePtr = (MSList) Marshal.PtrToStructure(msgListPtr, typeof (MSList));
if (msMessagePtr.data != IntPtr.Zero)
{
IntPtr tmpPtr = LinphoneAPI.linphone_chat_message_get_from_address(msMessagePtr.data);
tmpPtr = LinphoneAPI.linphone_address_as_string(tmpPtr);
if (tmpPtr != IntPtr.Zero)
{
var fromParty = LinphoneAPI.PtrToStringUtf8(tmpPtr).TrimSipPrefix();
LinphoneAPI.ortp_free(tmpPtr);
tmpPtr = LinphoneAPI.linphone_chat_message_get_to_address(msMessagePtr.data);
if (tmpPtr != IntPtr.Zero)
{
tmpPtr = LinphoneAPI.linphone_address_as_string(tmpPtr);
var toParty = LinphoneAPI.PtrToStringUtf8(tmpPtr).TrimSipPrefix();
LinphoneAPI.ortp_free(tmpPtr);
string dn, un, host;
int port;
if (fromParty == loggedInContact.ID || toParty == loggedInContact.ID)
{
bool isOutgoing = false;
string remoteParty = fromParty;
if (fromParty == loggedInContact.ID)
{
isOutgoing = true;
remoteParty = toParty;
}
if (
!VATRPCall.ParseSipAddressEx(remoteParty, out dn, out un,
out host, out port))
un = "";
if (un.NotBlank())
{
var contactAddress = string.Format("{0}@{1}", un, host);
var contactID = new ContactID(contactAddress, IntPtr.Zero);
var contact = FindContact(contactID);
if (contact == null)
{
contact = new VATRPContact(contactID)
{
DisplayName = dn,
Fullname = un,
SipUsername = un,
RegistrationName = contactAddress
};
_contactSvc.AddContact(contact, "");
}
IntPtr msgPtr = LinphoneAPI.linphone_chat_message_get_text(msMessagePtr.data);
var messageString = string.Empty;
if (msgPtr != IntPtr.Zero)
messageString = LinphoneAPI.PtrToStringUtf8(msgPtr);
if (messageString.NotBlank())
{
var localTime =
Time.ConvertUtcTimeToLocalTime(
LinphoneAPI.linphone_chat_message_get_time(msMessagePtr.data));
var declineMessage = false;
if (messageString.StartsWith(VATRPChatMessage.DECLINE_PREFIX))
{
messageString = messageString.Substring(VATRPChatMessage.DECLINE_PREFIX.Length);
declineMessage = true;
}
var chatMessage = new VATRPChatMessage(MessageContentType.Text)
{
Direction =
isOutgoing
? MessageDirection.Outgoing
: MessageDirection.Incoming,
IsIncompleteMessage = false,
MessageTime = localTime,
Content = messageString,
IsRTTMessage = false,
IsDeclineMessage = declineMessage,
IsRead = LinphoneAPI.linphone_chat_message_is_read(msMessagePtr.data) == 1,
Status = LinphoneAPI.linphone_chat_message_get_state(msMessagePtr.data),
Chat = chat
};
chat.AddMessage(chatMessage, false);
chat.UpdateLastMessage(false);
}
}
}
}
}
}
msgListPtr = msMessagePtr.next;
} while (msMessagePtr.next != IntPtr.Zero);
}
}
private void OnCallStateChanged(IntPtr lc, IntPtr callPtr, LinphoneCallState cstate, string message)
{
if (linphoneCore == IntPtr.Zero) return;
LOG.Info(string.Format( "OnCallStateChanged: State - {0}, CallPtr - {1}, Message: {2}", cstate, callPtr, message));
var newstate = VATRPCallState.None;
var direction = LinphoneCallDir.LinphoneCallIncoming;
string remoteParty = "";
IntPtr addressStringPtr;
bool removeCall = false;
// detecting direction, state and source-destination data by state
switch (cstate)
{
case LinphoneCallState.LinphoneCallIncomingReceived:
case LinphoneCallState.LinphoneCallIncomingEarlyMedia:
newstate = cstate == LinphoneCallState.LinphoneCallIncomingReceived
? VATRPCallState.InProgress
: VATRPCallState.EarlyMedia;
addressStringPtr = LinphoneAPI.linphone_call_get_remote_address_as_string(callPtr);
if (addressStringPtr != IntPtr.Zero)
{
identity = Marshal.PtrToStringAnsi(addressStringPtr);
LinphoneAPI.ortp_free(addressStringPtr);
}
remoteParty = identity;
break;
case LinphoneCallState.LinphoneCallOutgoingEarlyMedia:
case LinphoneCallState.LinphoneCallConnected:
newstate = VATRPCallState.Connected;
break;
case LinphoneCallState.LinphoneCallStreamsRunning:
newstate = VATRPCallState.StreamsRunning;
break;
case LinphoneCallState.LinphoneCallPausedByRemote:
newstate = VATRPCallState.RemotePaused;
break;
case LinphoneCallState.LinphoneCallPausing:
newstate = VATRPCallState.LocalPausing;
break;
case LinphoneCallState.LinphoneCallPaused:
newstate = VATRPCallState.LocalPaused;
break;
case LinphoneCallState.LinphoneCallResuming:
newstate = VATRPCallState.LocalResuming;
break;
case LinphoneCallState.LinphoneCallOutgoingInit:
case LinphoneCallState.LinphoneCallOutgoingProgress:
case LinphoneCallState.LinphoneCallOutgoingRinging:
newstate = cstate != LinphoneCallState.LinphoneCallOutgoingRinging
? VATRPCallState.Trying
: VATRPCallState.Ringing;
direction = LinphoneCallDir.LinphoneCallOutgoing;
addressStringPtr = LinphoneAPI.linphone_call_get_remote_address_as_string(callPtr);
if (addressStringPtr != IntPtr.Zero)
{
remoteParty = Marshal.PtrToStringAnsi(addressStringPtr);
LinphoneAPI.ortp_free(addressStringPtr);
}
break;
case LinphoneCallState.LinphoneCallError:
string linphoneLibraryVersion = VATRP.LinphoneWrapper.LinphoneAPI.linphone_core_get_version_asString();
LOG.Info("OnCallStateChanged: CallState=LinphoneCallError .LinphoneLib Version: " + linphoneLibraryVersion);
newstate = VATRPCallState.Error;
removeCall = true;
break;
case LinphoneCallState.LinphoneCallEnd:
newstate = VATRPCallState.Closed;
removeCall = true;
break;
case LinphoneCallState.LinphoneCallReleased:
if ((_declinedCallsList != null) && _declinedCallsList.Contains(callPtr))
{
LOG.Info(" trying to remove callPtr from declinedCallList");
_declinedCallsList.Remove(callPtr);
}
LOG.Info(" calling linphone_call_unref");
try
{
LinphoneAPI.linphone_call_unref(callPtr);
LOG.Info(" passed unref");
}
catch (Exception ex)
{
LOG.Error("LinphoneService.OnCallStateChanged: Exception occured while calling linphone_call_unref. Details: " + ex.Message);
}
return;
}
lock (callLock)
{
VATRPCall call = FindCall(callPtr);
if (call == null)
{
if (_declinedCallsList.Contains(callPtr))
return;
if (GetActiveCallsCount > 1)
{
callPtr = LinphoneAPI.linphone_call_ref(callPtr);
var cmd = new DeclineCallCommand(callPtr, LinphoneReason.LinphoneReasonBusy);
commandQueue.Enqueue(cmd);
_declinedCallsList.Add(callPtr);
return;
}
if (!removeCall)
{
LOG.Info("Call not found. Adding new call into list. ID - " + callPtr + " Calls count: " +
callsList.Count);
callPtr = LinphoneAPI.linphone_call_ref(callPtr);
call = new VATRPCall(callPtr) {CallState = newstate, CallDirection = direction};
CallParams from = direction == LinphoneCallDir.LinphoneCallIncoming ? call.From : call.To;
CallParams to = direction == LinphoneCallDir.LinphoneCallIncoming ? call.To : call.From;
if (
!VATRPCall.ParseSipAddressEx(remoteParty, out from.DisplayName, out from.Username,
out from.HostAddress,
out from.HostPort))
from.Username = "******";
if (
!VATRPCall.ParseSipAddressEx(remoteParty, out to.DisplayName, out to.Username, out to.HostAddress,
out to.HostPort))
to.Username = "******";
IntPtr chatPtr = LinphoneAPI.linphone_call_get_chat_room(callPtr);
if (chatPtr != IntPtr.Zero)
{
VATRPContact contact;
var contactAddress = string.Empty;
if (direction == LinphoneCallDir.LinphoneCallIncoming)
{
contactAddress = string.Format("{0}@{1}", from.Username, from.HostAddress);
contact = new VATRPContact(new ContactID(contactAddress, chatPtr))
{
DisplayName = from.DisplayName,
Fullname = from.Username,
SipUsername = from.Username
};
}
else
{
contactAddress = string.Format("{0}@{1}", to.Username, to.HostAddress);
contact = new VATRPContact(new ContactID(contactAddress, chatPtr))
{
DisplayName = to.DisplayName,
Fullname = to.Username,
SipUsername = to.Username
};
}
contact.RegistrationName = contactAddress;
call.ChatRoom = manager.ChatService.InsertRttChat(contact, chatPtr, callPtr);
var loggedContact = manager.ContactService.FindLoggedInContact();
if (loggedContact != null)
call.ChatRoom.AddContact(loggedContact);
}
callsList.Add(call);
}
}
if (call != null)
{
call.LinphoneMessage = message;
call.CallState = newstate;
if (call.CallState == VATRPCallState.Error || call.CallState == VATRPCallState.Closed)
{
IntPtr errorReason = LinphoneAPI.linphone_call_get_error_info(callPtr);
if (errorReason != IntPtr.Zero)
{
call.SipErrorCode = LinphoneAPI.linphone_error_info_get_protocol_code(errorReason);
}
}
if (CallStateChangedEvent != null)
CallStateChangedEvent(call);
if (removeCall)
{
callsList.Remove(call);
LOG.Info(string.Format("Call removed from list. Call - {0}. Total calls in list: {1}", callPtr,
callsList.Count));
}
}
}
}
private void OnChatMessageComposing(string remoteUser, IntPtr chatPtr, uint rttCode)
{
string dn, un, host;
int port;
System.Windows.Threading.Dispatcher dispatcher = null;
try
{
dispatcher = this._serviceManager.Dispatcher;
}
catch (NullReferenceException)
{
return;
}
if (dispatcher != null)
dispatcher.BeginInvoke((Action) delegate()
{
if (!VATRPCall.ParseSipAddressEx(remoteUser, out dn, out un,
out host, out port))
un = "";
if (!un.NotBlank() )
return;
var contactAddress = string.Format("{0}@{1}", un, host);
var contactID = new ContactID(contactAddress, IntPtr.Zero);
VATRPContact contact = FindContact(contactID);
if (contact == null)
{
contact = new VATRPContact(contactID)
{
DisplayName = dn,
Fullname = dn.NotBlank() ? dn : un,
RegistrationName = remoteUser,
SipUsername = un
};
_contactSvc.AddContact(contact, "");
}
VATRPChat chat = GetChat(contact);
chat.UnreadMsgCount++;
chat.CharsCountInBubble++;
var rttCodeArray = new char[2];
var rttCodearrayLength = 1;
if (chat.CharsCountInBubble == 201)
{
rttCodeArray[0] = UNLF;
try
{
rttCodeArray[1] = Convert.ToChar(rttCode);
}
catch (Exception)
{
}
rttCodearrayLength = 2;
chat.CharsCountInBubble = 0;
}
else
{
try
{
rttCodeArray[0] = Convert.ToChar(rttCode);
}
catch
{
}
}
for (int i = 0; i < rttCodearrayLength; i++)
{
VATRPChatMessage message = chat.SearchIncompleteMessage(MessageDirection.Incoming);
if (message == null)
{
message = new VATRPChatMessage(MessageContentType.Text)
{
Direction = MessageDirection.Incoming,
IsIncompleteMessage = true,
Chat = chat,
IsRTTMarker = false,
};
chat.AddMessage(message, false);
}
try
{
var sb = new StringBuilder(message.Content);
switch (rttCodeArray[i])
{
case UNLF: //
case CR:
case LF:
message.IsIncompleteMessage = false;
break;
case '\b':
if (sb.Length > 0)
sb.Remove(sb.Length - 1, 1);
break;
default:
sb.Append(rttCodeArray[i]);
break;
}
if (message.IsIncompleteMessage)
message.Content = sb.ToString();
}
catch (Exception ex)
{
Debug.WriteLine("Error in OnChatMessageComposing: " + ex.Message);
message.IsIncompleteMessage = false;
}
if (string.IsNullOrEmpty(message.Content))
chat.DeleteMessage(message);
else
chat.UpdateLastMessage(false);
this.OnConversationUpdated(chat, true);
if (this.RttReceived != null)
{
this.RttReceived(this, EventArgs.Empty);
}
}
});
}
