csharp-sdk-upm/RTM/Source/Public/AVIMClient.cs

1196 lines
45 KiB
C#
Raw Normal View History

2019-07-19 15:01:34 +08:00
using LeanCloud;
using LeanCloud.Storage.Internal;
using LeanCloud.Realtime.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace LeanCloud.Realtime
{
/// <summary>
/// 代表一个实时通信的终端用户
/// </summary>
public class AVIMClient
{
private readonly string clientId;
private readonly AVRealtime _realtime;
internal readonly object mutex = new object();
internal readonly object patchMutex = new object();
/// <summary>
/// 一些可变的配置选项,便于应对各种需求场景
/// </summary>
public struct Configuration
{
/// <summary>
/// Gets or sets a value indicating whether this <see cref="T:LeanCloud.Realtime.AVIMClient.Configuration"/>
/// auto read.
/// </summary>
/// <value><c>true</c> if auto read; otherwise, <c>false</c>.</value>
public bool AutoRead { get; set; }
}
/// <summary>
/// Gets or sets the current configuration.
/// </summary>
/// <value>The current configuration.</value>
public Configuration CurrentConfiguration
{
get; set;
}
internal AVRealtime LinkedRealtime
{
get { return _realtime; }
}
/// <summary>
/// 单点登录所使用的 Tag
/// </summary>
public string Tag
{
get;
private set;
}
/// <summary>
/// 客户端的标识,在一个 Application 内唯一。
/// </summary>
public string ClientId
{
get { return clientId; }
}
//private EventHandler<AVIMNotice> m_OnNoticeReceived;
///// <summary>
///// 接收到服务器的命令时触发的事件
///// </summary>
//public event EventHandler<AVIMNotice> OnNoticeReceived
//{
// add
// {
// m_OnNoticeReceived += value;
// }
// remove
// {
// m_OnNoticeReceived -= value;
// }
//}
private int onMessageReceivedCount = 0;
private EventHandler<AVIMMessageEventArgs> m_OnMessageReceived;
/// <summary>
/// 接收到聊天消息的事件通知
/// </summary>
public event EventHandler<AVIMMessageEventArgs> OnMessageReceived
{
add
{
onMessageReceivedCount++;
AVRealtime.PrintLog("AVIMClient.OnMessageReceived event add with " + onMessageReceivedCount + " times");
m_OnMessageReceived += value;
}
remove
{
onMessageReceivedCount--;
AVRealtime.PrintLog("AVIMClient.OnMessageReceived event remove with" + onMessageReceivedCount + " times");
m_OnMessageReceived -= value;
}
}
/// <summary>
/// Occurs when on members joined.
/// </summary>
public event EventHandler<AVIMOnMembersJoinedEventArgs> OnMembersJoined;
/// <summary>
/// Occurs when on members left.
/// </summary>
public event EventHandler<AVIMOnMembersLeftEventArgs> OnMembersLeft;
/// <summary>
/// Occurs when on kicked.
/// </summary>
public event EventHandler<AVIMOnKickedEventArgs> OnKicked;
/// <summary>
/// Occurs when on invited.
/// </summary>
public event EventHandler<AVIMOnInvitedEventArgs> OnInvited;
internal event EventHandler<AVIMMessageEventArgs> OnOfflineMessageReceived;
private EventHandler<AVIMSessionClosedEventArgs> m_OnSessionClosed;
/// <summary>
/// 当前打开的链接被迫关闭时触发的事件回调
/// <remarks>可能的原因有单点登录冲突,或者被 REST API 强制踢下线</remarks>
/// </summary>
public event EventHandler<AVIMSessionClosedEventArgs> OnSessionClosed
{
add
{
m_OnSessionClosed += value;
}
remove
{
m_OnSessionClosed -= value;
}
}
/// <summary>
/// 创建 AVIMClient 对象
/// </summary>
/// <param name="clientId"></param>
/// <param name="realtime"></param>
internal AVIMClient(string clientId, AVRealtime realtime)
: this(clientId, null, realtime)
{
}
/// <summary>
///
/// </summary>
/// <param name="clientId"></param>
/// <param name="tag"></param>
/// <param name="realtime"></param>
internal AVIMClient(string clientId, string tag, AVRealtime realtime)
{
this.clientId = clientId;
Tag = tag ?? tag;
_realtime = realtime;
#region sdk 强制在接收到消息之后一定要向服务端回发 ack
var ackListener = new AVIMMessageListener();
ackListener.OnMessageReceived += AckListener_OnMessageReceieved;
//this.RegisterListener(ackListener);
#endregion
#region 默认要为当前 client 绑定一个消息的监听器,用作消息的事件通知
var messageListener = new AVIMMessageListener();
messageListener.OnMessageReceived += MessageListener_OnMessageReceived;
this.RegisterListener(messageListener);
#endregion
#region 默认要为当前 client 绑定一个 session close 的监听器,用来监测单点登录冲突的事件通知
var sessionListener = new SessionListener();
sessionListener.OnSessionClosed += SessionListener_OnSessionClosed;
this.RegisterListener(sessionListener);
#endregion
#region 默认要为当前 client 监听 Ta 所出的对话中的人员变动的被动消息通知
var membersJoinedListener = new AVIMMembersJoinListener();
membersJoinedListener.OnMembersJoined += MembersJoinedListener_OnMembersJoined;
this.RegisterListener(membersJoinedListener);
var membersLeftListener = new AVIMMembersLeftListener();
membersLeftListener.OnMembersLeft += MembersLeftListener_OnMembersLeft;
this.RegisterListener(membersLeftListener);
var invitedListener = new AVIMInvitedListener();
invitedListener.OnInvited += InvitedListener_OnInvited;
this.RegisterListener(invitedListener);
var kickedListener = new AVIMKickedListener();
kickedListener.OnKicked += KickedListener_OnKicked;
this.RegisterListener(kickedListener);
#endregion
#region 当前 client id 离线的时间内TA 所在的对话产生的普通消息会以离线消息的方式送达到 TA 下一次登录的客户端
var offlineMessageListener = new OfflineMessageListener();
offlineMessageListener.OnOfflineMessageReceived += OfflineMessageListener_OnOfflineMessageReceived;
this.RegisterListener(offlineMessageListener);
#endregion
#region 当前 client 离线期间内产生的未读消息可以通过之后调用 Conversation.SyncStateAsync 获取一下离线期间内的未读状态
var unreadListener = new ConversationUnreadListener();
this.RegisterListener(unreadListener);
#endregion
#region 消息补丁(修改或者撤回)
var messagePatchListener = new MessagePatchListener();
messagePatchListener.OnReceived = (messages) =>
{
foreach (var message in messages) {
if (message is AVIMRecalledMessage) {
m_OnMessageRecalled?.Invoke(this, new AVIMMessagePatchEventArgs(message));
} else {
m_OnMessageUpdated?.Invoke(this, new AVIMMessagePatchEventArgs(message));
}
}
};
this.RegisterListener(messagePatchListener);
#endregion
#region configuration
CurrentConfiguration = new Configuration()
{
AutoRead = true,
};
#endregion
}
private void OfflineMessageListener_OnOfflineMessageReceived(object sender, AVIMMessageEventArgs e)
{
if (OnOfflineMessageReceived != null)
{
OnOfflineMessageReceived(this, e);
}
this.AckListener_OnMessageReceieved(sender, e);
}
private void KickedListener_OnKicked(object sender, AVIMOnKickedEventArgs e)
{
if (OnKicked != null)
OnKicked(this, e);
}
private void InvitedListener_OnInvited(object sender, AVIMOnInvitedEventArgs e)
{
if (OnInvited != null)
OnInvited(this, e);
}
private void MembersLeftListener_OnMembersLeft(object sender, AVIMOnMembersLeftEventArgs e)
{
if (OnMembersLeft != null)
OnMembersLeft(this, e);
}
private void MembersJoinedListener_OnMembersJoined(object sender, AVIMOnMembersJoinedEventArgs e)
{
if (OnMembersJoined != null)
OnMembersJoined(this, e);
}
private void SessionListener_OnSessionClosed(int arg1, string arg2, string arg3)
{
if (m_OnSessionClosed != null)
{
var args = new AVIMSessionClosedEventArgs()
{
Code = arg1,
Reason = arg2,
Detail = arg3
};
if (args.Code == 4115 || args.Code == 4111)
{
this._realtime.sessionConflict = true;
}
m_OnSessionClosed(this, args);
}
AVRealtime.PrintLog("SessionListener_OnSessionClosed invoked.");
//this.LinkedRealtime.LogOut();
}
private void MessageListener_OnMessageReceived(object sender, AVIMMessageEventArgs e)
{
if (this.m_OnMessageReceived != null)
{
this.m_OnMessageReceived.Invoke(this, e);
}
this.AckListener_OnMessageReceieved(sender, e);
}
private void AckListener_OnMessageReceieved(object sender, AVIMMessageEventArgs e)
{
lock (mutex)
{
var ackCommand = new AckCommand().MessageId(e.Message.Id)
.ConversationId(e.Message.ConversationId);
// 在 v.2 协议下,只要在线收到消息,就默认是已读的,下次上线不会再把当前消息当做未读消息
if (this.LinkedRealtime.CurrentConfiguration.OfflineMessageStrategy == AVRealtime.OfflineMessageStrategy.UnreadNotice)
{
ackCommand = ackCommand.ReadAck();
}
this.RunCommandAsync(ackCommand);
}
}
private void UpdateUnreadNotice(object sender, AVIMMessageEventArgs e)
{
ConversationUnreadListener.UpdateNotice(e.Message);
}
#region listener
/// <summary>
/// 注册 IAVIMListener
/// </summary>
/// <param name="listener"></param>
/// <param name="runtimeHook"></param>
public void RegisterListener(IAVIMListener listener, Func<AVIMNotice, bool> runtimeHook = null)
{
_realtime.SubscribeNoticeReceived(listener, runtimeHook);
}
#region get client instance
/// <summary>
/// Get the specified clientId.
/// </summary>
/// <returns>The get.</returns>
/// <param name="clientId">Client identifier.</param>
public static AVIMClient Get(string clientId)
{
if (AVRealtime.clients == null || !AVRealtime.clients.ContainsKey(clientId)) throw new Exception(string.Format("no client found with a id in {0}", clientId));
return AVRealtime.clients[clientId];
}
#endregion
#endregion
/// <summary>
/// 创建对话
/// </summary>
/// <param name="conversation">对话</param>
/// <param name="isUnique">是否创建唯一对话,当 isUnique 为 true 时,如果当前已经有相同成员的对话存在则返回该对话,否则会创建新的对话。该值默认为 false。</param>
/// <returns></returns>
internal Task<AVIMConversation> CreateConversationAsync(AVIMConversation conversation, bool isUnique = true)
{
var cmd = new ConversationCommand()
.Generate(conversation)
.Unique(isUnique);
var convCmd = cmd.Option("start")
.PeerId(clientId);
return LinkedRealtime.AttachSignature(convCmd, LinkedRealtime.SignatureFactory.CreateStartConversationSignature(this.clientId, conversation.MemberIds)).OnSuccess(_ =>
{
return this.RunCommandAsync(convCmd).OnSuccess(t =>
{
var result = t.Result;
if (result.Item1 < 1)
{
var members = conversation.MemberIds.ToList();
members.Add(ClientId);
conversation.MemberIds = members;
conversation.MergeFromPushServer(result.Item2);
}
return conversation;
});
}).Unwrap();
}
/// <summary>
/// 创建与目标成员的对话.
/// </summary>
/// <returns>返回对话实例.</returns>
/// <param name="member">目标成员.</param>
/// <param name="members">目标成员列表.</param>
/// <param name="name">对话名称.</param>
/// <param name="isSystem">是否是系统对话.</param>
/// <param name="isTransient">是否为暂态对话(聊天室).</param>
/// <param name="isUnique">是否是唯一对话.</param>
/// <param name="options">自定义属性.</param>
public Task<AVIMConversation> CreateConversationAsync(string member = null,
IEnumerable<string> members = null,
string name = "",
bool isSystem = false,
bool isTransient = false,
bool isUnique = true,
bool isTemporary = false,
int ttl = 86400,
IDictionary<string, object> options = null)
{
if (member == null) member = ClientId;
var membersAsList = Concat<string>(member, members, "创建对话时被操作的 member(s) 不可以为空。");
var conversation = new AVIMConversation(members: membersAsList,
name: name,
isUnique: isUnique,
isSystem: isSystem,
isTransient: isTransient,
isTemporary: isTemporary,
ttl: ttl,
client: this);
if (options != null)
{
foreach (var key in options.Keys)
{
conversation[key] = options[key];
}
}
return CreateConversationAsync(conversation, isUnique);
}
/// <summary>
/// Creates the conversation async.
/// </summary>
/// <returns>The conversation async.</returns>
/// <param name="builder">Builder.</param>
public Task<AVIMConversation> CreateConversationAsync(IAVIMConversatioBuilder builder)
{
var conversation = builder.Build();
return CreateConversationAsync(conversation, conversation.IsUnique);
}
/// <summary>
/// Gets the conversatio builder.
/// </summary>
/// <returns>The conversatio builder.</returns>
public AVIMConversationBuilder GetConversationBuilder()
{
var builder = AVIMConversationBuilder.CreateDefaultBuilder();
builder.Client = this;
return builder;
}
/// <summary>
/// 创建虚拟对话,对话 id 是由本地直接生成,云端根据规则消息发送给指定的 client id(s)
/// </summary>
/// <param name="member"></param>
/// <param name="members"></param>
/// <param name="ttl">过期时间,默认是一天(86400 秒),单位是秒</param>
/// <returns></returns>
public Task<AVIMConversation> CreateTemporaryConversationAsync(string member = null,
IEnumerable<string> members = null, int ttl = 86400)
{
if (member == null) member = ClientId;
var membersAsList = Concat<string>(member, members, "创建对话时被操作的 member(s) 不可以为空。");
return CreateConversationAsync(member, membersAsList, isTemporary: true, ttl: ttl);
}
/// <summary>
/// 创建聊天室(即:暂态对话)
/// </summary>
/// <param name="chatroomName">聊天室名称</param>
/// <returns></returns>
public Task<AVIMConversation> CreateChatRoomAsync(string chatroomName)
{
return CreateConversationAsync(name: chatroomName, isTransient: true);
}
/// <summary>
/// 获取一个对话
/// </summary>
/// <param name="id">对话的 ID</param>
/// <param name="noCache">从服务器获取</param>
/// <returns></returns>
public Task<AVIMConversation> GetConversationAsync(string id, bool noCache = true)
{
if (!noCache) return Task.FromResult(new AVIMConversation(this) { ConversationId = id });
else
{
return this.GetQuery().WhereEqualTo("objectId", id).FirstAsync();
}
}
#region send message
/// <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;
});
}
#endregion
#region mute & unmute
/// <summary>
/// 当前用户对目标对话进行静音操作
/// </summary>
/// <param name="conversation"></param>
/// <returns></returns>
public Task MuteConversationAsync(AVIMConversation conversation)
{
var convCmd = new ConversationCommand()
.ConversationId(conversation.ConversationId)
.Option("mute")
.PeerId(this.ClientId);
return this.RunCommandAsync(convCmd);
}
/// <summary>
/// 当前用户对目标对话取消静音,恢复该对话的离线消息推送
/// </summary>
/// <param name="conversation"></param>
/// <returns></returns>
public Task UnmuteConversationAsync(AVIMConversation conversation)
{
var convCmd = new ConversationCommand()
.ConversationId(conversation.ConversationId)
.Option("unmute")
.PeerId(this.ClientId);
return this.RunCommandAsync(convCmd);
}
#endregion
#region Conversation members operations
internal Task OperateMembersAsync(AVIMConversation conversation, string action, string member = null, IEnumerable<string> members = null)
{
if (string.IsNullOrEmpty(conversation.ConversationId))
{
throw new Exception("conversation id 不可以为空。");
}
var membersAsList = Concat<string>(member, members, "加人或者踢人的时候,被操作的 member(s) 不可以为空。");
var cmd = new ConversationCommand().ConversationId(conversation.ConversationId)
.Members(membersAsList)
.Option(action)
.PeerId(clientId);
return this.LinkedRealtime.AttachSignature(cmd, LinkedRealtime.SignatureFactory.CreateConversationSignature(conversation.ConversationId, ClientId, membersAsList, ConversationSignatureAction.Add)).OnSuccess(_ =>
{
return this.RunCommandAsync(cmd).OnSuccess(t =>
{
var result = t.Result;
if (!conversation.IsTransient)
{
if (conversation.MemberIds == null) conversation.MemberIds = new List<string>();
conversation.MemberIds = conversation.MemberIds.Concat(membersAsList);
}
return result;
});
}).Unwrap();
}
internal IEnumerable<T> Concat<T>(T single, IEnumerable<T> collection, string exString = null)
{
List<T> asList = null;
if (collection == null)
{
collection = new List<T>();
}
asList = collection.ToList();
if (asList.Count == 0 && single == null)
{
exString = exString ?? "can not cancat a collection with a null value.";
throw new ArgumentNullException(exString);
}
asList.Add(single);
return asList;
}
#region Join
/// <summary>
/// 当前用户加入到目标的对话中
/// </summary>
/// <param name="conversation">目标对话</param>
/// <returns></returns>
public Task JoinAsync(AVIMConversation conversation)
{
return this.OperateMembersAsync(conversation, "add", this.ClientId);
}
#endregion
#region Invite
/// <summary>
/// 直接将其他人加入到目标对话
/// <remarks>被操作的人会在客户端会触发 OnInvited 事件,而已经存在于对话的用户会触发 OnMembersJoined 事件</remarks>
/// </summary>
/// <param name="conversation">目标对话</param>
/// <param name="member">单个的 Client Id</param>
/// <param name="members">Client Id 集合</param>
/// <returns></returns>
public Task InviteAsync(AVIMConversation conversation, string member = null, IEnumerable<string> members = null)
{
return this.OperateMembersAsync(conversation, "add", member, members);
}
#endregion
#region Left
/// <summary>
/// 当前 Client 离开目标对话
/// <remarks>可以理解为是 QQ 群的退群操作</remarks>
/// <remarks></remarks>
/// </summary>
/// <param name="conversation">目标对话</param>
/// <returns></returns>
[Obsolete("use LeaveAsync instead.")]
public Task LeftAsync(AVIMConversation conversation)
{
return this.OperateMembersAsync(conversation, "remove", this.ClientId);
}
/// <summary>
/// Leaves the conversation async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="conversation">Conversation.</param>
public Task LeaveAsync(AVIMConversation conversation)
{
return this.OperateMembersAsync(conversation, "remove", this.ClientId);
}
#endregion
#region Kick
/// <summary>
/// 从目标对话中剔除成员
/// </summary>
/// <param name="conversation">目标对话</param>
/// <param name="member">被剔除的单个成员</param>
/// <param name="members">被剔除的成员列表</param>
/// <returns></returns>
public Task KickAsync(AVIMConversation conversation, string member = null, IEnumerable<string> members = null)
{
return this.OperateMembersAsync(conversation, "remove", member, members);
}
#endregion
#endregion
#region Query && Message history && ack
/// <summary>
/// Get conversation query.
/// </summary>
/// <returns></returns>
public AVIMConversationQuery GetQuery()
{
return GetConversationQuery();
}
/// <summary>
/// Get conversation query.
/// </summary>
/// <returns>The conversation query.</returns>
public AVIMConversationQuery GetConversationQuery()
{
return new AVIMConversationQuery(this);
}
#region load message history
/// <summary>
/// 查询目标对话的历史消息
/// <remarks>不支持聊天室(暂态对话)</remarks>
/// </summary>
/// <param name="conversation">目标对话</param>
/// <param name="beforeMessageId">从 beforeMessageId 开始向前查询(和 beforeTimeStampPoint 共同使用,为防止某毫秒时刻有重复消息)</param>
/// <param name="afterMessageId"> 截止到某个 afterMessageId (不包含)</param>
/// <param name="beforeTimeStampPoint">从 beforeTimeStampPoint 开始向前查询</param>
/// <param name="afterTimeStampPoint">拉取截止到 afterTimeStampPoint 时间戳(不包含)</param>
/// <param name="direction">查询方向,默认是 1如果是 1 表示从新消息往旧消息方向, 0 则相反,其他值无效</param>
/// <param name="limit">拉取消息条数,默认值 20 条,可设置为 1 - 1000 之间的任意整数</param>
/// <returns></returns>
public Task<IEnumerable<T>> QueryMessageAsync<T>(AVIMConversation conversation,
string beforeMessageId = null,
string afterMessageId = null,
DateTime? beforeTimeStampPoint = null,
DateTime? afterTimeStampPoint = null,
int direction = 1,
int limit = 20)
where T : IAVIMMessage
{
var maxLimit = 1000;
var actualLimit = limit > maxLimit ? maxLimit : limit;
var logsCmd = new AVIMCommand()
.Command("logs")
.Argument("cid", conversation.ConversationId)
.Argument("l", actualLimit);
if (beforeMessageId != null)
{
logsCmd = logsCmd.Argument("mid", beforeMessageId);
}
if (afterMessageId != null)
{
logsCmd = logsCmd.Argument("tmid", afterMessageId);
}
if (beforeTimeStampPoint != null && beforeTimeStampPoint.Value != DateTime.MinValue)
{
logsCmd = logsCmd.Argument("t", beforeTimeStampPoint.Value.ToUnixTimeStamp());
}
if (afterTimeStampPoint != null && afterTimeStampPoint.Value != DateTime.MinValue)
{
logsCmd = logsCmd.Argument("tt", afterTimeStampPoint.Value.ToUnixTimeStamp());
}
if (direction == 0)
{
logsCmd = logsCmd.Argument("direction", "NEW");
}
var subMessageType = typeof(T);
var subTypeInteger = subMessageType == typeof(AVIMTypedMessage) ? 0 : FreeStyleMessageClassInfo.GetTypedInteger(subMessageType.GetTypeInfo());
if (subTypeInteger != 0)
{
logsCmd = logsCmd.Argument("lctype", subTypeInteger);
}
return this.RunCommandAsync(logsCmd).OnSuccess(t =>
{
var rtn = new List<IAVIMMessage>();
var result = t.Result.Item2;
var logs = result["logs"] as List<object>;
if (logs != null)
{
foreach (var log in logs)
{
var logMap = log as IDictionary<string, object>;
if (logMap != null)
{
var msgStr = logMap["data"].ToString();
var messageObj = AVRealtime.FreeStyleMessageClassingController.Instantiate(msgStr, logMap);
messageObj.ConversationId = conversation.ConversationId;
rtn.Add(messageObj);
}
}
}
conversation.OnMessageLoad(rtn);
return rtn.AsEnumerable().OfType<T>();
});
}
#endregion
//public Task MarkAsReadAsync(string conversationId = null, string messageId = null, AVIMConversation conversation = null, AVIMMessage message = null)
//{
// var msgId = messageId != null ? messageId : message.Id;
// var convId = conversationId != null ? conversationId : conversation.ConversationId;
// if (convId == null && msgId == null) throw new ArgumentNullException("发送已读回执的时候,必须指定 conversation id 或者 message id");
// lock (mutex)
// {
// var ackCommand = new AckCommand()
// .ReadAck().MessageId(msgId)
// .ConversationId(convId)
// .PeerId(this.ClientId);
// return this.RunCommandAsync(ackCommand);
// }
//}
#region 查询对话中对方的接收状态,也就是已读回执
private Task<Tuple<long, long>> FetchAllReceiptTimestampsAsync(string targetClientId = null, string conversationId = null, AVIMConversation conversation = null, bool queryAllMembers = false)
{
var convId = conversationId != null ? conversationId : conversation.ConversationId;
if (convId == null) throw new ArgumentNullException("conversationId 和 conversation 不可以同时为 null");
var cmd = new ConversationCommand().ConversationId(convId)
.TargetClientId(targetClientId)
.QueryAllMembers(queryAllMembers)
.Option("max-read")
.PeerId(clientId);
return this.RunCommandAsync(cmd).OnSuccess(t =>
{
var result = t.Result;
long maxReadTimestamp = -1;
long maxAckTimestamp = -1;
if (result.Item2.ContainsKey("maxReadTimestamp"))
{
long.TryParse(result.Item2["maxReadTimestamp"].ToString(), out maxReadTimestamp);
}
if (result.Item2.ContainsKey("maxAckTimestamp"))
{
long.TryParse(result.Item2["maxAckTimestamp"].ToString(), out maxAckTimestamp);
}
return new Tuple<long, long>(maxAckTimestamp, maxReadTimestamp);
});
}
#endregion
#region 查询对方是否在线
/// <summary>
/// 查询对方 client Id 是否在线
/// </summary>
/// <param name="targetClientId">单个 client Id</param>
/// <param name="targetClientIds">多个 client Id 集合</param>
/// <returns></returns>
public Task<IEnumerable<Tuple<string, bool>>> PingAsync(string targetClientId = null, IEnumerable<string> targetClientIds = null)
{
List<string> queryIds = null;
if (targetClientIds != null) queryIds = targetClientIds.ToList();
if (queryIds == null && string.IsNullOrEmpty(targetClientId)) throw new ArgumentNullException("必须查询至少一个 client id 的状态targetClientId 和 targetClientIds 不可以同时为空");
queryIds.Add(targetClientId);
var cmd = new SessionCommand()
.SessionPeerIds(queryIds)
.Option("query");
return this.RunCommandAsync(cmd).OnSuccess(t =>
{
var result = t.Result;
List<Tuple<string, bool>> rtn = new List<Tuple<string, bool>>();
var onlineSessionPeerIds = AVDecoder.Instance.DecodeList<string>(result.Item2["onlineSessionPeerIds"]);
foreach (var peerId in targetClientIds)
{
rtn.Add(new Tuple<string, bool>(peerId, onlineSessionPeerIds.Contains(peerId)));
}
return rtn.AsEnumerable();
});
}
#endregion
#region 获取暂态对话在线人数
/// <summary>
/// 获取暂态对话(聊天室)在线人数,依赖缓存,并不一定 100% 与真实数据一致。
/// </summary>
/// <param name="chatroomId"></param>
/// <returns></returns>
public Task<int> CountOnlineClientsAsync(string chatroomId)
{
var command = new AVCommand(relativeUri: "rtm/transient_group/onlines?gid=" + chatroomId, method: "GET",
sessionToken: null,
headers: null,
data: null);
return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).OnSuccess(t =>
{
var result = t.Result.Item2;
if (result.ContainsKey("result"))
{
return int.Parse(result["result"].ToString());
}
return -1;
});
}
#endregion
#endregion
#region mark as read
/// <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);
}
/// <summary>
/// mark the conversation as read with conversation id.
/// </summary>
/// <param name="conversationId">conversation id</param>
/// <returns></returns>
public Task ReadAsync(string conversationId)
{
var conv = AVIMConversation.CreateWithoutData(conversationId, this);
return this.ReadAsync(conv);
}
/// <summary>
/// mark all conversations as read.
/// </summary>
/// <returns></returns>
public Task ReadAllAsync()
{
var cids = ConversationUnreadListener.FindAllConvIds();
var readCmd = new ReadCommand().ConvIds(cids).PeerId(this.ClientId);
return this.RunCommandAsync(readCmd);
}
#endregion
#region recall & modify
/// <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>
/// 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;
}
internal EventHandler<AVIMMessagePatchEventArgs> m_OnMessageRecalled;
/// <summary>
/// Occurs when on message recalled.
/// </summary>
public event EventHandler<AVIMMessagePatchEventArgs> OnMessageRecalled
{
add
{
this.m_OnMessageRecalled += value;
}
remove
{
this.m_OnMessageRecalled -= value;
}
}
internal EventHandler<AVIMMessagePatchEventArgs> m_OnMessageUpdated;
/// <summary>
/// Occurs when on message modified.
/// </summary>
public event EventHandler<AVIMMessagePatchEventArgs> OnMessageUpdated
{
add
{
this.m_OnMessageUpdated += value;
}
remove
{
this.m_OnMessageUpdated -= value;
}
}
#endregion
#region log out
/// <summary>
/// 退出登录或者切换账号
/// </summary>
/// <returns></returns>
public Task CloseAsync()
{
var cmd = new SessionCommand().Option("close");
return this.RunCommandAsync(cmd).ContinueWith(t =>
{
m_OnSessionClosed(this, null);
});
}
#endregion
/// <summary>
/// Run command async.
/// </summary>
/// <returns>The command async.</returns>
/// <param name="command">Command.</param>
public Task<Tuple<int, IDictionary<string, object>>> RunCommandAsync(AVIMCommand command)
{
command.PeerId(this.ClientId);
return this.LinkedRealtime.RunCommandAsync(command);
}
/// <summary>
/// Run command.
/// </summary>
/// <param name="command">Command.</param>
public void RunCommand(AVIMCommand command)
{
command.PeerId(this.ClientId);
this.LinkedRealtime.RunCommand(command);
}
}
/// <summary>
/// AVIMClient extensions.
/// </summary>
public static class AVIMClientExtensions
{
/// <summary>
/// Create conversation async.
/// </summary>
/// <returns>The conversation async.</returns>
/// <param name="client">Client.</param>
/// <param name="members">Members.</param>
public static Task<AVIMConversation> CreateConversationAsync(this AVIMClient client, IEnumerable<string> members)
{
return client.CreateConversationAsync(members: members);
}
public static Task<AVIMConversation> CreateConversationAsync(this AVIMClient client, IEnumerable<string> members, string conversationName)
{
return client.CreateConversationAsync(members: members, name: conversationName);
}
/// <summary>
/// Get conversation.
/// </summary>
/// <returns>The conversation.</returns>
/// <param name="client">Client.</param>
/// <param name="conversationId">Conversation identifier.</param>
public static AVIMConversation GetConversation(this AVIMClient client, string conversationId)
{
return AVIMConversation.CreateWithoutData(conversationId, client);
}
/// <summary>
/// Join conversation async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="client">Client.</param>
/// <param name="conversationId">Conversation identifier.</param>
public static Task JoinAsync(this AVIMClient client, string conversationId)
{
var conversation = client.GetConversation(conversationId);
return client.JoinAsync(conversation);
}
/// <summary>
/// Leave conversation async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="client">Client.</param>
/// <param name="conversationId">Conversation identifier.</param>
public static Task LeaveAsync(this AVIMClient client, string conversationId)
{
var conversation = client.GetConversation(conversationId);
return client.LeaveAsync(conversation);
}
/// <summary>
/// Query messages.
/// </summary>
/// <returns>The message async.</returns>
/// <param name="client">Client.</param>
/// <param name="conversation">Conversation.</param>
/// <param name="beforeMessageId">Before message identifier.</param>
/// <param name="afterMessageId">After message identifier.</param>
/// <param name="beforeTimeStampPoint">Before time stamp point.</param>
/// <param name="afterTimeStampPoint">After time stamp point.</param>
/// <param name="direction">Direction.</param>
/// <param name="limit">Limit.</param>
public static Task<IEnumerable<IAVIMMessage>> QueryMessageAsync(this AVIMClient client,
AVIMConversation conversation,
string beforeMessageId = null,
string afterMessageId = null,
DateTime? beforeTimeStampPoint = null,
DateTime? afterTimeStampPoint = null,
int direction = 1,
int limit = 20)
{
return client.QueryMessageAsync<IAVIMMessage>(conversation,
beforeMessageId,
afterMessageId,
beforeTimeStampPoint,
afterTimeStampPoint,
direction,
limit);
}
/// <summary>
/// Get the chat room query.
/// </summary>
/// <returns>The chat room query.</returns>
/// <param name="client">Client.</param>
public static AVIMConversationQuery GetChatRoomQuery(this AVIMClient client)
{
return client.GetQuery().WhereEqualTo("tr", true);
}
}
}