public void Handle(TLUpdateChatUserTyping update)
{
var chatBase = CacheService.GetChat(update.ChatId) as TLChatBase;
if (chatBase != null)
{
_typingManagers.TryGetValue(update.ChatId, out InputTypingManager typingManager);
if (typingManager == null)
{
typingManager = new InputTypingManager(users =>
{
chatBase.TypingSubtitle = DialogViewModel.GetTypingString(chatBase.ToPeer(), users, CacheService.GetUser, null);
chatBase.IsTyping = true;
},
() =>
{
chatBase.TypingSubtitle = null;
chatBase.IsTyping = false;
});
_typingManagers[update.ChatId] = typingManager;
}
var action = update.Action;
if (action is TLSendMessageCancelAction)
{
typingManager.RemoveTypingUser(update.UserId);
return;
}
typingManager.AddTypingUser(update.UserId, action);
}
}
public void Handle(TLUpdateEncryptedChatTyping encryptedChatTyping)
{
if (Chat != null &&
With != null &&
Chat.Index == encryptedChatTyping.ChatId.Value)
{
BeginOnThreadPool(() => InputTypingManager.AddTypingUser(With.Index, new TLSendMessageTypingAction()));
}
}
public void Handle(UpdateUserChatAction update)
{
if (update.ChatId == _chat?.Id)
{
if (update.Action is ChatActionCancel)
{
BeginOnUIThread(() => InputTypingManager.RemoveTypingUser(update.UserId));
}
else
{
BeginOnUIThread(() => InputTypingManager.AddTypingUser(update.UserId, update.Action));
}
}
}
private async void InsertMessage(TLMessageCommonBase messageCommon)
{
using (await _insertLock.WaitAsync())
{
var result = new List <TLMessageBase> {
messageCommon
};
ProcessReplies(result);
messageCommon = result.FirstOrDefault() as TLMessageCommonBase;
if (messageCommon == null)
{
return;
}
BeginOnUIThread(() =>
{
var index = InsertMessageInOrder(Items, messageCommon);
if (index < 0)
{
return;
}
if (messageCommon is TLMessage message && !message.IsOut && message.HasFromId && message.HasReplyMarkup && message.ReplyMarkup != null)
{
var user = CacheService.GetUser(message.FromId) as TLUser;
if (user != null && user.IsBot)
{
SetReplyMarkup(message);
if (message.ReplyMarkup is TLReplyKeyboardMarkup)
{
InputPane.GetForCurrentView().TryHide();
}
}
}
Execute.BeginOnThreadPool(() =>
{
MarkAsRead(messageCommon);
if (messageCommon is TLMessage)
{
InputTypingManager.RemoveTypingUser(messageCommon.FromId ?? 0);
}
});
});
}
}
public void Handle(TLUpdateUserTyping update)
{
var user = CacheService.GetUser(update.UserId) as TLUser;
if (user == null)
{
return;
}
if (user.IsSelf)
{
return;
}
var dialog = CacheService.GetDialog(user.ToPeer());
if (dialog == null)
{
return;
}
_typingManagers.TryGetValue(update.UserId, out InputTypingManager typingManager);
if (typingManager == null)
{
typingManager = new InputTypingManager(users =>
{
dialog.TypingSubtitle = DialogViewModel.GetTypingString(user.ToPeer(), users, CacheService.GetUser, null);
dialog.IsTyping = true;
},
() =>
{
dialog.TypingSubtitle = null;
dialog.IsTyping = false;
});
_typingManagers[update.UserId] = typingManager;
}
var action = update.Action;
if (action is TLSendMessageCancelAction)
{
typingManager.RemoveTypingUser(update.UserId);
return;
}
typingManager.AddTypingUser(update.UserId, action);
}
public void Handle(TLUpdateChatUserTyping chatUserTyping)
{
var chatBase = With as TLChatBase;
if (chatBase != null && chatBase.Id == chatUserTyping.ChatId)
{
var action = chatUserTyping.Action;
if (action is TLSendMessageCancelAction)
{
InputTypingManager.RemoveTypingUser(chatUserTyping.UserId);
return;
}
InputTypingManager.AddTypingUser(chatUserTyping.UserId, action);
}
}
public void Handle(TLUpdateUserTyping userTyping)
{
var user = this.With as TLUser;
if (user != null && !user.IsSelf && user.Id == userTyping.UserId)
{
var action = userTyping.Action;
if (action is TLSendMessageCancelAction)
{
InputTypingManager.RemoveTypingUser(userTyping.UserId);
return;
}
InputTypingManager.AddTypingUser(userTyping.UserId, action);
}
}
private void HandleTypingCommon(TLUpdateTypingBase updateTyping)
{
TLSendMessageActionBase action = new TLSendMessageTypingAction();
var updateUserTyping17 = updateTyping as IUserTypingAction;
if (updateUserTyping17 != null)
{
action = updateUserTyping17.Action;
}
if (action is TLSendMessageCancelAction)
{
InputTypingManager.RemoveTypingUser(updateTyping.UserId.Value);
}
else
{
InputTypingManager.AddTypingUser(updateTyping.UserId.Value, action);
}
}
public void Handle(TLDecryptedMessageBase decryptedMessage)
{
if (Chat != null &&
decryptedMessage.ChatId.Value == Chat.Id.Value)
{
System.Diagnostics.Debug.WriteLine("Handle random_id={0} date={1} qts={2}", decryptedMessage.RandomId, decryptedMessage.Date, decryptedMessage.Qts);
var serviceMessage = decryptedMessage as TLDecryptedMessageService;
if (serviceMessage != null)
{
var action = serviceMessage.Action;
var typingAction = action as TLDecryptedMessageActionTyping;
if (typingAction != null)
{
var cancelAction = typingAction.Action as TLSendMessageCancelAction;
if (cancelAction != null)
{
InputTypingManager.RemoveTypingUser(With.Index);
}
else
{
InputTypingManager.AddTypingUser(With.Index, typingAction.Action);
}
}
var setMessageTTLAction = action as TLDecryptedMessageActionSetMessageTTL;
if (setMessageTTLAction != null)
{
Chat.MessageTTL = setMessageTTLAction.TTLSeconds;
}
var flushHistoryAction = action as TLDecryptedMessageActionFlushHistory;
if (flushHistoryAction != null)
{
Execute.BeginOnUIThread(() => Items.Clear());
CacheService.ClearDecryptedHistoryAsync(Chat.Id);
}
var readMessagesAction = action as TLDecryptedMessageActionReadMessages;
if (readMessagesAction != null)
{
Execute.BeginOnUIThread(() =>
{
foreach (var randomId in readMessagesAction.RandomIds)
{
foreach (var item in UngroupEnumerator(Items))
{
if (item.RandomId.Value == randomId.Value)
{
item.Status = MessageStatus.Read;
if (item.TTL != null && item.TTL.Value > 0)
{
item.DeleteDate = new TLLong(DateTime.Now.Ticks + Chat.MessageTTL.Value * TimeSpan.TicksPerSecond);
}
var decryptedMessage17 = item as TLDecryptedMessage17;
if (decryptedMessage17 != null)
{
var decryptedMediaPhoto = decryptedMessage17.Media as TLDecryptedMessageMediaPhoto;
if (decryptedMediaPhoto != null)
{
if (decryptedMediaPhoto.TTLParams == null)
{
var ttlParams = new TTLParams();
ttlParams.IsStarted = true;
ttlParams.Total = decryptedMessage17.TTL.Value;
ttlParams.StartTime = DateTime.Now;
ttlParams.Out = decryptedMessage17.Out.Value;
decryptedMediaPhoto.TTLParams = ttlParams;
}
}
var decryptedMediaVideo17 = decryptedMessage17.Media as TLDecryptedMessageMediaVideo17;
if (decryptedMediaVideo17 != null)
{
if (decryptedMediaVideo17.TTLParams == null)
{
var ttlParams = new TTLParams();
ttlParams.IsStarted = true;
ttlParams.Total = decryptedMessage17.TTL.Value;
ttlParams.StartTime = DateTime.Now;
ttlParams.Out = decryptedMessage17.Out.Value;
decryptedMediaVideo17.TTLParams = ttlParams;
}
}
var decryptedMediaAudio17 = decryptedMessage17.Media as TLDecryptedMessageMediaAudio17;
if (decryptedMediaAudio17 != null)
{
if (decryptedMediaAudio17.TTLParams == null)
{
var ttlParams = new TTLParams();
ttlParams.IsStarted = true;
ttlParams.Total = decryptedMessage17.TTL.Value;
ttlParams.StartTime = DateTime.Now;
ttlParams.Out = decryptedMessage17.Out.Value;
decryptedMediaAudio17.TTLParams = ttlParams;
}
}
var decryptedMediaDocument45 = decryptedMessage17.Media as TLDecryptedMessageMediaDocument45;
if (decryptedMediaDocument45 != null && (decryptedMessage17.IsVoice() || decryptedMessage17.IsVideo()))
{
if (decryptedMediaDocument45.TTLParams == null)
{
var ttlParams = new TTLParams();
ttlParams.IsStarted = true;
ttlParams.Total = decryptedMessage17.TTL.Value;
ttlParams.StartTime = DateTime.Now;
ttlParams.Out = decryptedMessage17.Out.Value;
decryptedMediaDocument45.TTLParams = ttlParams;
}
var message45 = decryptedMessage17 as TLDecryptedMessage45;
if (message45 != null)
{
message45.SetListened();
}
decryptedMediaDocument45.NotListened = false;
decryptedMediaDocument45.NotifyOfPropertyChange(() => decryptedMediaDocument45.NotListened);
}
}
item.NotifyOfPropertyChange(() => item.Status);
break;
}
}
}
});
}
var deleteMessagesAction = action as TLDecryptedMessageActionDeleteMessages;
if (deleteMessagesAction != null)
{
Execute.BeginOnUIThread(() =>
{
var group = new Dictionary <long, TLDecryptedMessageMediaGroup>();
foreach (var randomId in deleteMessagesAction.RandomIds)
{
for (var i = 0; i < Items.Count; i++)
{
var groupedMessage = false;
var message73 = Items[i] as TLDecryptedMessage73;
if (message73 != null && message73.GroupedId != null)
{
var mediaGroup = message73.Media as TLDecryptedMessageMediaGroup;
if (mediaGroup != null)
{
groupedMessage = true;
for (var k = 0; k < mediaGroup.Group.Count; k++)
{
if (mediaGroup.Group[k].RandomId.Value == randomId.Value)
{
mediaGroup.Group.RemoveAt(k);
if (mediaGroup.Group.Count == 0)
{
Items.Remove(message73);
}
else
{
group[message73.GroupedId.Value] = mediaGroup;
}
break;
}
}
}
}
if (!groupedMessage && Items[i].RandomId.Value == randomId.Value)
{
Items.RemoveAt(i);
break;
}
}
}
foreach (var mediaGroup in group.Values)
{
mediaGroup.RaiseCalculate();
}
CacheService.DeleteDecryptedMessages(deleteMessagesAction.RandomIds);
});
}
}
if (!TLUtils.IsDisplayedDecryptedMessage(decryptedMessage))
{
return;
}
ProcessMessages(new List <TLDecryptedMessageBase> {
decryptedMessage
});
Execute.OnUIThread(() =>
{
var addedGrouped = false;
var message73 = decryptedMessage as TLDecryptedMessage73;
if (message73 != null && message73.GroupedId != null && Items.Count > 0)
{
var previousMessage = Items[0] as TLDecryptedMessage73;
if (previousMessage != null &&
previousMessage.GroupedId != null &&
previousMessage.GroupedId.Value == message73.GroupedId.Value)
{
Items.RemoveAt(0);
var items = new List <TLDecryptedMessageBase>();
var mediaGroup = previousMessage.Media as TLDecryptedMessageMediaGroup;
if (mediaGroup != null)
{
items.Add(message73);
for (var i = mediaGroup.Group.Count - 1; i >= 0; i--)
{
items.Add(mediaGroup.Group[i]);
}
}
else
{
items.Add(message73);
items.Add(previousMessage);
}
ProcessGroupedMessages(items);
for (var j = 0; j < items.Count; j++)
{
InsertMessageInOrder(items[j]);
}
addedGrouped = true;
}
}
var position = -1;
if (!addedGrouped)
{
position = InsertMessageInOrder(decryptedMessage);
System.Diagnostics.Debug.WriteLine("Handle.Insert random_id={0} date={1} position={2}", decryptedMessage.RandomId, decryptedMessage.Date, position);
}
else
{
position = 0;
}
NotifyOfPropertyChange(() => DescriptionVisibility);
if (position != -1)
{
ReadMessages(decryptedMessage);
if (decryptedMessage is TLDecryptedMessage)
{
InputTypingManager.RemoveTypingUser(With.Index);
}
}
});
}
}
private void InsertMessage(TLMessageCommon message)
{
ProcessRepliesAndAudio(new List <TLMessageBase> {
message
});
Execute.BeginOnUIThread(() =>
{
//if (LazyItems.Count > 0)
//{
// for (var i = 0; i < LazyItems.Count; i++)
// {
// if (LazyItems[i].DateIndex == message.DateIndex
// && LazyItems[i].Index == message.Index)
// {
// Execute.ShowDebugMessage("InsertMessage catch doubled message");
// return;
// }
// if (LazyItems[i].DateIndex < message.DateIndex)
// {
// break;
// }
// }
//}
var position = TLDialog.InsertMessageInOrder(Items, message);
_addedCount++;
//if (Items.Count > 30 && _addedCount >= 20)
//{
// _addedCount = 0;
// while (Items.Count > 30)
// {
// Items.RemoveAt(Items.Count - 1);
// }
//}
if (position != -1)
{
var message31 = message as TLMessage31;
if (message31 != null && !message31.Out.Value && message31.ReplyMarkup != null)
{
var fromId = message31.FromId;
var user = CacheService.GetUser(fromId) as TLUser;
if (user != null && user.IsBot)
{
SetReplyMarkup(message31);
}
}
Execute.BeginOnThreadPool(() =>
{
MarkAsRead(message);
if (message is TLMessage)
{
InputTypingManager.RemoveTypingUser(message.FromId.Value);
}
});
}
});
}
