public Message(IAVIMMessage textmessage)
{
if (textmessage is AVIMTextMessage)
{
Text = ((AVIMTextMessage)textmessage).TextContent;
Image = null;
}
else
{
Text = ((AVIMImageMessage)textmessage).TextContent;
//Image=new BitmapImage(((AVIMImageMessage)textmessage).File.Url, new System.Net.Cache.RequestCachePolicy());
Image = new BitmapImage(((AVIMImageMessage)textmessage).File.Url);
}
if (textmessage.FromClientId != AVUser.CurrentUser.ObjectId)
{
Alignment = HorizontalAlignment.Left;
Background = new SolidColorBrush(Colors.LightGray);
}
else
{
Alignment = HorizontalAlignment.Right;
Background = new SolidColorBrush(Colors.LightGreen);
}
}
public async Task <int> getHistoryMessage()
{
IEnumerable <IAVIMMessage> messages;
if (oldestMessage == null)
{
messages = (await conversation.QueryMessageAsync(limit: MessagePerPage));
}
else
{
messages = (await conversation.QueryMessageAsync(
beforeMessageId: oldestMessage.Id,
beforeTimeStamp: oldestMessage.ServerTimestamp,
limit: MessagePerPage));
}
foreach (var message in messages.Reverse())
{
if (message is AVIMTextMessage)
{
var textMessage = (AVIMTextMessage)message;
MessageItem newItem = fromIMTextMessage(textMessage);
itemList.Insert(0, newItem);
}
}
List <IAVIMMessage> list = messages.ToList();
if (list.Count > 0)
{
oldestMessage = list[0];
}
return(list.Count);
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="avMessage">消息体</param>
/// <param name="options">消息的发送选项，包含了一些特殊的标记<see cref="AVIMSendOptions"/></param>
/// <returns></returns>
public Task <IAVIMMessage> SendMessageAsync(IAVIMMessage avMessage, AVIMSendOptions options)
{
if (this.CurrentClient == null)
{
throw new Exception("当前对话未指定有效 AVIMClient，无法发送消息。");
}
return(this.CurrentClient.SendMessageAsync(this, avMessage, options));
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="avMessage">消息体</param>
/// <param name="options">消息的发送选项，包含了一些特殊的标记<see cref="AVIMSendOptions"/></param>
/// <returns></returns>
public Task <IAVIMMessage> SendMessageAsync(IAVIMMessage avMessage, AVIMSendOptions options)
{
if (this.CurrentClient == null)
{
throw new Exception("当前对话未指定有效 AVIMClient，无法发送消息。");
}
if (this.CurrentClient.LinkedRealtime.State != AVRealtime.Status.Online)
{
throw new Exception("未能连接到服务器，无法发送消息。");
}
return(this.CurrentClient.SendMessageAsync(this, avMessage, options));
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="invoker"></param>
/// <param name="adpater"></param>
public void RegisterMessage <T>(Action <IAVIMMessage> invoker, IAVIMMessage adpater)
where T : AVIMMessage
{
int typeEnum = AVIMMessage.GetMessageType <T>();
if (typeEnum < 0)
{
return;
}
messageHandlers[typeEnum] = invoker;
adpaters[typeEnum] = adpater;
}
/// <summary>
/// Recalls the async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="message">Message.</param>
public Task <AVIMRecalledMessage> RecallAsync(IAVIMMessage message)
{
var tcs = new TaskCompletionSource <AVIMRecalledMessage>();
var patchCmd = new PatchCommand().Recall(message);
RunCommandAsync(patchCmd)
.OnSuccess(t => {
var recalledMsg = new AVIMRecalledMessage();
AVIMMessage.CopyMetaData(message, recalledMsg);
tcs.SetResult(recalledMsg);
});
return(tcs.Task);
}
/// <summary>
/// 向目标对话发送消息
/// </summary>
/// <param name="conversation">目标对话</param>
/// <param name="message">消息体</param>
/// <returns></returns>
public Task <IAVIMMessage> SendMessageAsync(
AVIMConversation conversation,
IAVIMMessage message)
{
return(this.SendMessageAsync(conversation, message, new AVIMSendOptions()
{
Receipt = true,
Transient = false,
Priority = 1,
Will = false,
PushData = null,
}));
}
/// <summary>
/// 向目标对话发送消息
/// </summary>
/// <param name="conversation">目标对话</param>
/// <param name="message">消息体</param>
/// <param name="options">消息的发送选项，包含了一些特殊的标记<see cref="AVIMSendOptions"/></param>
/// <returns></returns>
public Task <IAVIMMessage> SendMessageAsync(
AVIMConversation conversation,
IAVIMMessage message,
AVIMSendOptions options)
{
if (this.LinkedRealtime.State != AVRealtime.Status.Online)
{
throw new Exception("未能连接到服务器，无法发送消息。");
}
var messageBody = message.Serialize();
message.ConversationId = conversation.ConversationId;
message.FromClientId = this.ClientId;
var cmd = new MessageCommand()
.Message(messageBody)
.ConvId(conversation.ConversationId)
.Receipt(options.Receipt)
.Transient(options.Transient)
.Priority(options.Priority)
.Will(options.Will)
.MentionAll(message.MentionAll);
if (message is AVIMMessage)
{
cmd = ((AVIMMessage)message).BeforeSend(cmd);
}
if (options.PushData != null)
{
cmd = cmd.PushData(options.PushData);
}
if (message.MentionList != null)
{
cmd = cmd.Mention(message.MentionList);
}
var directCmd = cmd.PeerId(this.ClientId);
return(this.RunCommandAsync(directCmd).OnSuccess(t =>
{
var response = t.Result.Item2;
message.Id = response["uid"].ToString();
message.ServerTimestamp = long.Parse(response["t"].ToString());
return message;
}));
}
internal static IAVIMMessage CopyMetaData(IAVIMMessage srcMsg, IAVIMMessage desMsg)
{
if (srcMsg == null)
{
return(desMsg);
}
desMsg.ConversationId = srcMsg.ConversationId;
desMsg.FromClientId = srcMsg.FromClientId;
desMsg.Id = srcMsg.Id;
desMsg.ServerTimestamp = srcMsg.ServerTimestamp;
desMsg.RcpTimestamp = srcMsg.RcpTimestamp;
desMsg.UpdatedAt = srcMsg.UpdatedAt;
return(desMsg);
}
public IDictionary <string, object> EncodeProperties(IAVIMMessage subclass)
{
var type = subclass.GetType();
var result = new Dictionary <string, object>();
var className = GetClassName(type);
var propertMappings = GetPropertyMappings(className);
foreach (var propertyPair in propertMappings)
{
var propertyInfo = ReflectionHelpers.GetProperty(type, propertyPair.Key);
var operation = propertyInfo.GetValue(subclass, null);
result[propertyPair.Value] = PointerOrLocalIdEncoder.Instance.Encode(operation);
}
return(result);
}
public PatchCommand Recall(IAVIMMessage message)
{
var patch = new Patch()
{
ConvId = message.ConversationId,
From = message.FromClientId,
MessageId = message.Id,
MetaTimestamp = message.ServerTimestamp,
Recall = true,
PatchTimestamp = DateTime.Now.UnixTimeStampSeconds()
};
this.Patches.Add(patch);
this.Argument("patches", this.EncodePatches());
return(new PatchCommand(this, this.Patches));
}
/// <summary>
/// 向该对话发送消息。
/// </summary>
/// <param name="avMessage">消息体</param>
/// <param name="receipt">是否需要送达回执</param>
/// <param name="transient">是否是暂态消息，暂态消息不返回送达回执(ack)，不保留离线消息，不触发离线推送</param>
/// <param name="priority">消息等级，默认是1，可选值还有 2 ，3</param>
/// <param name="will">标记该消息是否为下线通知消息</param>
/// <param name="pushData">如果消息的接收者已经下线了，这个字段的内容就会被离线推送到接收者
/// <remarks>例如，一张图片消息的离线消息内容可以类似于：[您收到一条图片消息，点击查看] 这样的推送内容，参照微信的做法</remarks>
/// </param>
/// <returns></returns>
public Task <IAVIMMessage> SendMessageAsync(IAVIMMessage avMessage,
bool receipt = true,
bool transient = false,
int priority = 1,
bool will = false,
IDictionary <string, object> pushData = null)
{
return(this.SendMessageAsync(avMessage, new AVIMSendOptions()
{
Receipt = receipt,
Transient = transient,
Priority = priority,
Will = will,
PushData = pushData
}));
}
public PatchCommand Modify(IAVIMMessage oldMessage, IAVIMMessage newMessage)
{
var patch = new Patch()
{
ConvId = oldMessage.ConversationId,
From = oldMessage.FromClientId,
MessageId = oldMessage.Id,
MetaTimestamp = oldMessage.ServerTimestamp,
Recall = false,
PatchTimestamp = DateTime.Now.UnixTimeStampSeconds(),
PatchData = newMessage.Serialize()
};
this.Patches.Add(patch);
this.Argument("patches", this.EncodePatches());
return(new PatchCommand(this, this.Patches));
}
/// <summary>
/// Modifies the aysnc.
/// </summary>
/// <returns>The aysnc.</returns>
/// <param name="oldMessage">要修改的消息对象</param>
/// <param name="newMessage">新的消息对象</param>
public Task <IAVIMMessage> UpdateAsync(IAVIMMessage oldMessage, IAVIMMessage newMessage)
{
var tcs = new TaskCompletionSource <IAVIMMessage>();
var patchCmd = new PatchCommand().Modify(oldMessage, newMessage);
this.RunCommandAsync(patchCmd)
.OnSuccess(t => {
// 从旧消息对象中拷贝数据
AVIMMessage.CopyMetaData(oldMessage, newMessage);
// 获取更新时间戳
var response = t.Result.Item2;
if (response.TryGetValue("lastPatchTime", out object updatedAtObj) &&
long.TryParse(updatedAtObj.ToString(), out long updatedAt))
{
newMessage.UpdatedAt = updatedAt;
}
tcs.SetResult(newMessage);
});
return(tcs.Task);
}
/// <summary>
/// 向目标对话发送消息
/// </summary>
/// <param name="conversation">目标对话</param>
/// <param name="message">消息体</param>
/// <param name="options">消息的发送选项，包含了一些特殊的标记<see cref="AVIMSendOptions"/></param>
/// <returns></returns>
public Task <IAVIMMessage> SendMessageAsync(
AVIMConversation conversation,
IAVIMMessage message,
AVIMSendOptions options = default(AVIMSendOptions))
{
var messageBody = message.Serialize();
message.ConversationId = conversation.ConversationId;
message.FromClientId = this.ClientId;
var cmd = new MessageCommand()
.Message(messageBody)
.ConvId(conversation.ConversationId)
.Receipt(options.Receipt)
.Transient(options.Transient)
.Priority(options.Priority)
.Will(options.Will);
if (options.PushData != null)
{
cmd.PushData(options.PushData);
}
var directCmd = cmd.PeerId(this.ClientId);
return(AVRealtime.AVIMCommandRunner.RunCommandAsync(directCmd).ContinueWith <IAVIMMessage>(t =>
{
if (t.IsFaulted)
{
throw t.Exception;
}
else
{
var response = t.Result.Item2;
message.Id = response["uid"].ToString();
message.ServerTimestamp = long.Parse(response["t"].ToString());
return message;
}
}));
}
/// <summary>
///
/// </summary>
/// <param name="conversation"></param>
/// <param name="message"></param>
/// <param name="readAt"></param>
/// <returns></returns>
public Task ReadAsync(AVIMConversation conversation, IAVIMMessage message = null, DateTime?readAt = null)
{
var convRead = new ReadCommand.ConvRead()
{
ConvId = conversation.ConversationId,
};
if (message != null)
{
convRead.MessageId = message.Id;
convRead.Timestamp = message.ServerTimestamp;
}
if (readAt != null && readAt.Value != DateTime.MinValue)
{
convRead.Timestamp = readAt.Value.ToUnixTimeStamp();
}
var readCmd = new ReadCommand().Conv(convRead).PeerId(this.ClientId);
this.RunCommandAsync(readCmd);
return(Task.FromResult(true));
}
public MessageViewModel(IAVIMMessage iMessage, string text = null)
{
this.Text = "当前客户端不支持显示此类型消息。";
if (iMessage != null)
{
if (iMessage is AVIMTextMessage)
{
this.Text = ((AVIMTextMessage)iMessage).TextContent;
}
else if (iMessage is AVIMMessage)
{
}
this.Sender = iMessage.FromClientId;
}
if (text != null)
{
this.Text = text;
}
if (this.Sender != null)
{
this.Code = this.Sender.First();
}
}
internal static void UpdateNotice(IAVIMMessage message)
{
lock (sMutex)
{
var convValidators = UnreadConversations.Where(c => c.ConvId == message.ConversationId);
if (convValidators != null)
{
if (convValidators.Count() > 0)
{
var currentNotice = convValidators.FirstOrDefault();
currentNotice.AutomicIncrement();
currentNotice.LastUnreadMessage = message;
}
else
{
var currentThread = new UnreadConversationNotice();
currentThread.ConvId = message.ConversationId;
currentThread.LastUnreadMessage = message;
currentThread.AutomicIncrement();
UnreadConversations.Add(currentThread);
}
}
}
}
public AVIMMessagePatchEventArgs(IAVIMMessage message)
{
Message = message;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:LeanCloud.Realtime.AVIMMessageEventArgs"/> class.
/// </summary>
/// <param name="iMessage">I message.</param>
public AVIMMessageEventArgs(IAVIMMessage iMessage)
{
Message = iMessage;
}
public AckCommand Message(IAVIMMessage message)
{
return(new AckCommand()
.ConversationId(message.ConversationId)
.MessageId(message.Id));
}
public Task ModifyAysnc(IAVIMMessage message)
{
return(this.ReplaceAsync(message, message));
}
public Task ReplaceAsync(IAVIMMessage oldMessage, IAVIMMessage newMessage)
{
var patchCmd = new PatchCommand().Modify(oldMessage, newMessage);
return(this.LinkedRealtime.RunCommandAsync(patchCmd));
}
public Task RecallAsync(IAVIMMessage message)
{
var patchCmd = new PatchCommand().Recall(message);
return(this.LinkedRealtime.RunCommandAsync(patchCmd));
}
public IAVIMMessage DecodeProperties(IAVIMMessage message, IDictionary <string, object> buildInData)
{
long timestamp;
if (buildInData.ContainsKey("timestamp"))
{
if (long.TryParse(buildInData["timestamp"].ToString(), out timestamp))
{
message.ServerTimestamp = timestamp;
}
}
long ackAt;
if (buildInData.ContainsKey("ackAt"))
{
if (long.TryParse(buildInData["ackAt"].ToString(), out ackAt))
{
message.RcpTimestamp = ackAt;
}
}
if (buildInData.ContainsKey("from"))
{
message.FromClientId = buildInData["from"].ToString();
}
if (buildInData.ContainsKey("msgId"))
{
message.Id = buildInData["msgId"].ToString();
}
if (buildInData.ContainsKey("cid"))
{
message.ConversationId = buildInData["cid"].ToString();
}
if (buildInData.ContainsKey("fromPeerId"))
{
message.FromClientId = buildInData["fromPeerId"].ToString();
}
if (buildInData.ContainsKey("id"))
{
message.Id = buildInData["id"].ToString();
}
if (buildInData.ContainsKey("mid"))
{
message.Id = buildInData["mid"].ToString();
}
if (buildInData.ContainsKey("mentionPids"))
{
message.MentionList = AVDecoder.Instance.DecodeList <string>(buildInData["mentionPids"]);
}
if (buildInData.TryGetValue("patchTimestamp", out object patchTimestampObj))
{
if (long.TryParse(patchTimestampObj.ToString(), out long patchTimestamp))
{
message.UpdatedAt = patchTimestamp;
}
}
bool mentionAll;
if (buildInData.ContainsKey("mentionAll"))
{
if (bool.TryParse(buildInData["mentionAll"].ToString(), out mentionAll))
{
message.MentionAll = mentionAll;
}
}
return(message);
}
