/// <summary>
/// 创建一个rtp能力可以识别的消息
/// </summary>
/// <param name="eventName"></param>
/// <param name="header"></param>
/// <param name="content"></param>
/// <returns></returns>
private Message CreateResponseMessage(string eventName, DTObject header, byte[] content, string error, bool isCompleted)
{
var rtpData = new RtpData(this.Data.Participant, header, content);
var data = RtpDataAnalyzer.Serialize(rtpData);
var msg = RtpCapability.CreateCallMessage(this.Name, eventName, data, this.RequestId, (mh) =>
{
if (!string.IsNullOrEmpty(this.Destination))
{
mh.SetValue(MessageField.Destination, this.Destination);
}
else if (this.Destinations != null)
{
mh.SetValue(MessageField.Destinations, this.Destinations);
}
if (!string.IsNullOrEmpty(error))
{
mh.SetValue(RtpCapability.FieldRtpCallErrorMessage, error);
}
mh.SetValue(RtpCapability.FieldRtpCallIsCompleted, isCompleted);
});
msg.Origin = this.Data.Participant.Orgin;
return(msg);
}
private Future <bool> RaiseEvent(string eventName,
DTObject header,
byte[] body,
Action <DTObject> setMessageHeader)
{
var rtpData = new RtpData(this.Channel.Participant, header, body);
var data = RtpDataAnalyzer.Serialize(rtpData);
Message msg = CreateMessage(eventName, data, setMessageHeader);
return(this.Channel.Context.Client.Send(msg));
}
/// <summary>
/// 远程调用，该调用非常强大，不仅可以同步或异步执行并且获取结果，更可以获取服务器端多次推送的结果
/// </summary>
/// <param name="header"></param>
/// <param name="body"></param>
/// <param name="future"></param>
private Future <bool> Call(string eventName, DTObject header, byte[] body, Action <RtpData, bool> process, Action <DTObject> setMessageHeader)
{
var identity = RtpCallManager.BorrowIdentity();
identity.Process = process;
var rtpData = new RtpData(this.Channel.Participant, header, body);
var data = RtpDataAnalyzer.Serialize(rtpData);
identity.Future.Start();
Message msg = CreateCallMessage(this.Name, eventName, data, identity.RequestId, setMessageHeader);
this.Channel.Context.Client.Send(msg);
return(identity.Future);
}
///// <summary>
///// 获得所在组播的信息
///// </summary>
///// <returns></returns>
//public Multicast GetMulticast()
//{
// return this.Channel.Context.Client.GetMulticast(this.Channel.HostAddress);
//}
internal static void Process(AnycastClient client, ClientEvents.MessageReceivedEventArgs ea)
{
var data = RtpDataAnalyzer.Deserialize(ea.Message.Origin, ea.Message.Body);
if (TryProcessCall(ea.Message, data))
{
return;
}
var header = ea.Message.Header;
var origin = ea.Message.Origin;
var eventName = header.GetValue <string>(FieldRtpEventName);
RaiseLocalEvent(client, origin, eventName, data);
}
public RtpCapabilityCallProxy(Message msg)
{
this.Name = msg.Header.GetValue <string>(RtpCapability.FieldRtpCapabilityName, string.Empty);
this.EventName = msg.Header.GetValue <string>(RtpCapability.FieldRtpEventName, string.Empty);
if (!string.IsNullOrEmpty(this.Name))
{
this.Data = RtpDataAnalyzer.Deserialize(msg.Origin, msg.Body);
var destination = msg.Header.GetValue <string>(MessageField.Destination, string.Empty);
if (!string.IsNullOrEmpty(destination))
{
this.Destination = destination;
}
var destinations = msg.Header.GetList(MessageField.Destinations, false)?.ToArray <string>();
if (destinations != null)
{
this.Destinations = destinations;
}
this.RequestId = msg.Header.GetValue <Guid>(RtpCapability.FieldRtpCallRequestId, Guid.Empty);
}
}
public static RtpData GetData(string origin, byte[] data)
{
return(RtpDataAnalyzer.Deserialize(origin, data));
}
public byte[] ToArray()
{
return(RtpDataAnalyzer.Serialize(this));
}
