private string __FirstHandShake(string detail)
{
//配置请求包
ServerRequestPackage reqtPkg = new ServerRequestPackage(true);
IMiddleware2ServerHandShakeRequest reqtInterface = reqtPkg.Active_Middleware2ServerHandShakeRequest();
reqtInterface.HandShake(false, detail);
ServerReplyPackage replyPkg = null;
replyPkg = _binProcessferProcessor.SynSendMessage(reqtPkg, 100000);
IMiddleware2ServerHandShakeReply replyInterface = replyPkg.Active_MiddlewareHandShakeReply();
bool ret;
string tokenOrErrorInfo;
replyInterface.HandShakeRet(out ret, out tokenOrErrorInfo);
if (true == ret)
{
return(tokenOrErrorInfo);
}
else
{
throw new InitializationExtion(tokenOrErrorInfo);
}
}
private void __Relink(string token)
{
//配置请求包
ServerRequestPackage reqtPkg = new ServerRequestPackage(true);
IMiddleware2ServerHandShakeRequest reqtInterface = reqtPkg.Active_Middleware2ServerHandShakeRequest();
reqtInterface.HandShake(true, token);
ServerReplyPackage replyPkg = null;
try
{
replyPkg = _binProcessferProcessor.SynSendMessage(reqtPkg, 100000);
}
catch (System.Exception ex)
{
throw ex;
}
bool ret;
string errorDetail;
IMiddleware2ServerHandShakeReply replyInterface = replyPkg.Active_MiddlewareHandShakeReply();
replyInterface.HandShakeRet(out ret, out errorDetail);
if (true == ret)
{
//nothing to do
}
else
{
throw new InitializationExtion(errorDetail);
}
}
internal void Radio(C2CRadioPackage radioPkg)
{
//配置请求包
ServerRequestPackage reqtPkg = new ServerRequestPackage(true);
IRadioMessageRequest reqtInterface = reqtPkg.Active_RadioMessageRequest();
reqtInterface.RadioMessage(radioPkg.Group.Token, radioPkg);
BinTransferLayer binProcessor = _mclLayerProcessor.BinTransferProcessor;
ServerReplyPackage replyPkg = null;
try
{
replyPkg = binProcessor.SynSendMessage(reqtPkg, 100000);
}
catch (System.Exception ex)
{
throw new RadioGroupExcetion(ex.ToString());
}
IRadioReply replyInterface = replyPkg.Active_RadioGroupReply();
bool ret;
string errorDetail;
replyInterface.RadioRet(out ret, out errorDetail);
if (true == ret)
{
//nothing to do
}
else
{
throw new RadioGroupExcetion(errorDetail);
}
}
internal GroupDevice GetGroup(string detail)
{
//配置请求包
ServerRequestPackage reqtPkg = new ServerRequestPackage(true);
IOnlineGroupListRequest reqtInterface = reqtPkg.Active_OnlineGroupListRequest();
reqtInterface.OnlineGroupRequest();
BinTransferLayer binprocessor = _mclLayerProcessor.BinTransferProcessor;
ServerReplyPackage replyPkg = null;
try
{
replyPkg = binprocessor.SynSendMessage(reqtPkg, 100000);
}
catch (Exception ex)
{
throw new GetOnlineGroupExcetion(ex.ToString());
}
IOnlineGroupReply replyInterface = replyPkg.Active_OnlineGroupReply();
bool ret;
string errorDetail;
List <CSCommunicateClass.GroupInfo> onlineGroupInfo;
replyInterface.OnlineGroupRet(out ret, out errorDetail, out onlineGroupInfo);
if (true == ret)
{
foreach (CSCommunicateClass.GroupInfo item in onlineGroupInfo)
{
if (item.Detail.Equals(detail))
{
GroupDevice gropInst = new GroupDevice(_mclLayerProcessor);
GroupDevice.Parse(item, gropInst);
try
{
//check join statucs
List <CSCommunicateClass.ClientInfo> clients = null;
GetGroupMembers(gropInst, out clients);
if ((null != clients) && (0 < clients.Count))
{
gropInst.Joined = true;
}
}
catch (System.Exception ex)
{
//nothing to do
}
return(gropInst);
}
}
throw new GetOnlineGroupExcetion("不存在指定名称的群组");
}
else
{
throw new GetOnlineGroupExcetion(errorDetail);
}
}
/// <summary>
/// 下层消息通知(有配对来源)
/// </summary>
/// <param name="reqtPkg">发起本次服务器请求的报文包</param>
/// <param name="rplyPkg">响应的服务器报文包</param>
internal void ServerMessageRecived(ServerRequestPackage reqtPkg, ServerReplyPackage rplyPkg)
{
//由于对下层调用的实现机制目前完全以同步调用实现，故触发此分支将是一个错误
throw new NotImplementedException("MiddleCommunicateLayer目前对Bin层调用全部以同步实现，执行此分支是一个错误");
//if (ServerReplyPackage.ReplyType.reply == rplyPkg.MsgType)
//{
// //判断服务器端执行是否挂掉
// if (true != rplyPkg.MiddlewarePkgTransferServOprRet)
// {
// //按挂掉的源请求是否同步区分处理
// bool bSynArrIndexExist = false;
// lock (_synReadLockObject)
// {
// bSynArrIndexExist = _synWattingMiddlewareReplyMessages.ContainsKey(reqtPkg.MTPkg.MessageId);
// }
// if (true == bSynArrIndexExist)
// {
// //处理同步消息错误
// MiddlewareTransferServerStateInfo servOprStat = MiddlewareTransferErrorExcetion.Parse(rplyPkg);
// (_synWattingMiddlewareReplyMessages[reqtPkg.MTPkg.MessageId] as WaitingMessage).State = servOprStat;
// //此处不清理同步资源，由__SendMessageAndWattingForResponse执行退出时完成
// }
// else
// {
// //处理异步消息错误,向上提交错误
// MiddlewareTransferPackage sourMtPkg = reqtPkg.MTPkg;
// MiddlewareTransferErrorExcetion transErrorExInfo = new MiddlewareTransferErrorExcetion(MiddlewareTransferErrorExcetion.Parse(rplyPkg));
// _middlewareCorelogicLayer.MiddlewareTransferErrorRecived(sourMtPkg, transErrorExInfo);
// //清理资源
// bool havWattingRecored;
// lock (_synReadLockObject)
// {
// havWattingRecored = _asynWattingMiddlewareReplyMessages.ContainsKey(sourMtPkg.MessageId);
// }
// if (havWattingRecored)
// {
// _asynWattingMiddlewareReplyMessages.Remove(sourMtPkg.MessageId);
// }
// }
// }
// else
// {
// //若中间件消息正常发送，则忽略掉此服务器报文，否则上报
// }
//}
//else
//{
// //有catch的报文必为服务器响应报文
// throw new Exception("有catch的报文必为服务器响应报文");
//}
}
internal void JoinGroup(GroupDevice group, GroupMemberRole role)
{
//配置请求包
ServerRequestPackage reqtPkg = new ServerRequestPackage(true);
IJoinGroupRequest reqtInterface = reqtPkg.Active_JoinGroupRequest();
if (group.Ready && !string.IsNullOrEmpty(group.Token))
{
reqtInterface.JoinGroup(group.Token, role);
}
else
{
throw new ArgumentNullException("Group token is null");
}
BinTransferLayer binprocessor = _mclLayerProcessor.BinTransferProcessor;
ServerReplyPackage replyPkg = null;
try
{
replyPkg = binprocessor.SynSendMessage(reqtPkg, 100000);
}
catch (System.Exception ex)
{
throw new JoinGroupExcetion(ex.ToString());
}
IJoinGroupReply replyInterface = replyPkg.Active_JoinGroupReply();
bool ret;
string detail;
replyInterface.JoinGroupRet(out ret, out detail);
if (true == ret)
{
//该部分逻辑内聚到Group内部
////加入成功
//group.Joined = true;
//try
//{
// //从接口的使用习惯上考虑，立即返回成员列表
// group.Referesh();
//}
//catch (RefereshGroupInfo ex)
//{
// //虽然刷新讯息抛出错误，但仍可以判定客户端已加入
// throw ex;
//}
}
else
{
throw new JoinGroupExcetion(detail);
}
}
/// <summary>
/// 非阻塞式执行一次消息发送请求
/// </summary>
/// <param name="mtPkg">发往远程中间件设备的消息包</param>
internal void AsynSendMessage(MiddlewareTransferPackage mtPkg)
{
//will send a message
if ((mtPkg is RequestMTPackage) && ((mtPkg as RequestMTPackage).WattingResponse))
{
__ActiveMiddlewareMessageWattinghere(mtPkg);
}
bool mustWaitReponse = true;
ServerRequestPackage wilSendScsMsg = new ServerRequestPackage(mustWaitReponse);
//配置为Middleware传输包
IMiddleware2MiddlewareCommunicatRequest statSeter = wilSendScsMsg.Active_MiddlewareCommunicatRequest();
statSeter.WilSendMiddleware2MiddlewareMessage(mtPkg.TargetDevice, mtPkg);
BinTransferLayer btlprocessor = _middlewareCorelogicLayer.BinTransferProcessor;
ServerReplyPackage replyServPkg = null;
try
{
replyServPkg = btlprocessor.SynSendMessage(wilSendScsMsg, 100000);
}
catch (System.Exception ex)
{
//TODO
throw new MiddlewareTransferErrorExcetion(ex);
}
//分析服务端报文
IMiddleware2MiddlewareCommunicatReply replyInterface = replyServPkg.Active_Middleware2MiddlewareCommunicatReply();
bool ret;
string detail;
try
{
replyInterface.SendMiddlewareMsgOprRet(out ret, out detail);
}
catch (Exception ex)
{
throw new MiddlewareTransferErrorExcetion(ex.ToString());
}
if (true == ret)
{
//noting to do
}
else
{
throw new MiddlewareTransferErrorExcetion(detail);
}
}
internal void ExitGroup(GroupDevice group)
{
if (!group.Ready || string.IsNullOrEmpty(group.Token))
{
throw new ExitGroupExcetion((new NullReferenceException("Group token is null")).ToString());
}
//配置请求包
ServerRequestPackage reqtPkg = new ServerRequestPackage(true);
IExitGroupRequest reqtInterface = reqtPkg.Active_ExitGroupRequest();
reqtInterface.ExitGroup(group.Token);
BinTransferLayer binprocessor = _mclLayerProcessor.BinTransferProcessor;
ServerReplyPackage replyPkg = null;
try
{
replyPkg = binprocessor.SynSendMessage(reqtPkg, 100000);
}
catch (Exception ex)
{
throw new ExitGroupExcetion(ex.ToString());
}
IExitGroupRely replyInterface = replyPkg.Active_ExitGroupReply();
bool ret;
string errorDetail;
replyInterface.ExitGroupRet(out ret, out errorDetail);
if (true == ret)
{
//该部分逻辑内聚到Group内部
//group.Joined = false;
//try
//{
// group.Referesh();
//}catch(RefereshGroupInfo ex)
//{
// throw ex;
//}
}
else
{
throw new ExitGroupExcetion(errorDetail);
}
}
///// <summary>
///// 阻塞式执行一次消息发送请求
///// </summary>
///// <param name="reqtPkg">发往服务端的消息包</param>
///// <returns>服务端返回报文包</returns>
//internal ServerCtrReplyPackage SynSendMessage(ServerRequestPackage reqtPkg)
//{
// //TODO
// //同步能力在下一个子版本中实现
// throw new NotImplementedException();
//}
///// <summary>
///// 非阻塞的执行一次消息发送请求
///// </summary>
///// <param name="reqtPkg">发往服务端的消息包</param>
//internal void ASynSendMessage(ServerRequestPackage reqtPkg)
//{
//}
/// <summary>
/// 下层消息通知
/// </summary>
/// <param name="rplyPkg">服务端响应报文包</param>
internal void ServerMessageRecived(ServerReplyPackage rplyPkg)
{
if ((ServerReplyPackage.ReplyType.middleware_propagate == rplyPkg.MsgType) && (null != rplyPkg.MTPkg))
{
__ProcessMiddlewareMessageRecived(rplyPkg.MTPkg);
}
else
{
if (ServerReplyPackage.ReplyType.middleware_propagate != rplyPkg.MsgType)
{
//由于未索引的应答报文已经被BinLayer放弃，执行到此分支是一个错误
throw new Exception("一个未被catch的应答报文");
}
if (null == rplyPkg.MTPkg)
{
//无法解析的中间件消息包
throw new NotImplementedException("无法解析的中间件消息包");
}
}
}
internal void GetGroupMembers(GroupDevice gropDevice, out List <CSCommunicateClass.ClientInfo> onlineGroupMembers)
{
//配置数据包
ServerRequestPackage servReqtPkg = new ServerRequestPackage(true);
IOnlineGroupClientRequest reqtInterface = servReqtPkg.Active_OnlineGroupClientRequest();
reqtInterface.OnlineGroupClientRequest(gropDevice.Token);
BinTransferLayer binprocessor = _mclLayerProcessor.BinTransferProcessor;
ServerReplyPackage servReplyPkg = null;
try
{
servReplyPkg = binprocessor.SynSendMessage(servReqtPkg, 100000);
}
catch (System.Exception ex)
{
throw new GetOnlineGroupClientExcetion(ex.ToString());
}
IOnlineGroupClientReply replyInterface = servReplyPkg.Active_OnlineGroupClientReply();
bool ret;
string errorDetail;
try
{
replyInterface.OnlineGroupClientRet(out ret, out errorDetail, out onlineGroupMembers);
}
catch (Exception ex)
{
throw new GetOnlineGroupClientExcetion(ex.ToString());
}
if (true == ret)
{
//nothing to do
}
else
{
throw new GetOnlineGroupClientExcetion(errorDetail);
}
}
internal GroupDevice CreateGroup(string detail)
{
//配置请求包
ServerRequestPackage reqtPkg = new ServerRequestPackage(true);
ICreateGroupRequest reqtInterface = reqtPkg.Active_CreateGroupRequest();
reqtInterface.CreateNewGroup(detail);
BinTransferLayer binprocessor = _mclLayerProcessor.BinTransferProcessor;
ServerReplyPackage replyPkg = null;
try
{
replyPkg = binprocessor.SynSendMessage(reqtPkg, 100000);
}
catch (System.Exception ex)
{
//throw timeout excetion
throw new CreateGroupExcetion(ex.ToString());
}
ICreateGroupReply replyInterface = replyPkg.Active_CreateGroupReply();
bool ret;
string detailOrToken;
replyInterface.CreateGroupRet(out ret, out detailOrToken);
if (true == ret)
{
GroupDevice retGrop = new GroupDevice(_mclLayerProcessor);
retGrop.Token = detailOrToken;
retGrop.Detail = detail;
retGrop.Ready = true;
return(retGrop);
}
else
{
throw new CreateGroupExcetion(detailOrToken);
}
}
private MiddlewareTransferPackage __SendMessageAndWattingForResponse(MiddlewareTransferPackage msg, int timeoutMilliseconds)
{
WaitingMessage waitMsg = new WaitingMessage();
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages[msg.MessageId] = waitMsg;
}
//send message
bool mustWaitReponse = true;
ServerRequestPackage wilSendServMsg = new ServerRequestPackage(mustWaitReponse);
//配置为中间件传输包
IMiddleware2MiddlewareCommunicatRequest statSetter = wilSendServMsg.Active_MiddlewareCommunicatRequest();
statSetter.WilSendMiddleware2MiddlewareMessage(msg.TargetDevice, msg);
BinTransferLayer btlpeocessor = _middlewareCorelogicLayer.BinTransferProcessor;
ServerReplyPackage replyServPkg = null;
try
{
replyServPkg = btlpeocessor.SynSendMessage(wilSendServMsg, 100000);
}
catch (System.Exception ex)
{
//释放锁记录
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages.Remove(msg.MessageId);
}
throw new MiddlewareTransferErrorExcetion(ex.ToString());
}
//分析服务端报文
IMiddleware2MiddlewareCommunicatReply replyInterface = replyServPkg.Active_Middleware2MiddlewareCommunicatReply();
bool ret;
string detail;
replyInterface.SendMiddlewareMsgOprRet(out ret, out detail);
if (true == ret)
{
//noting to do
}
else
{
throw new MiddlewareTransferErrorExcetion(detail);
}
//wait for the recived event
waitMsg.WaitEvent.Wait(timeoutMilliseconds);
//Check for exceptions
switch (waitMsg.State)
{
case MiddlewareTransferServerStateInfo.WaittingForResponse:
{
//同步超时
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages.Remove(msg.MessageId);
}
throw new MiddlewareTransferErrorExcetion(MiddlewareTransferServerStateInfo.TimeOut.ToString());
}
case MiddlewareTransferServerStateInfo.ResponseReceived:
{
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages.Remove(msg.MessageId);
}
break;
}
}
return(waitMsg.ResponseMessage);
}
/// <summary>
/// 下层消息通知(有配对来源)
/// </summary>
/// <param name="sclPkg">发起服务器请求的报文包</param>
/// <param name="scrPkg">响应的服务器报文包</param>
internal void ServerMessageRecived(ServerRequestPackage reqtPkg, ServerReplyPackage rplyPkg)
{
throw new NotImplementedException();
}
internal void ServerMessageRecived(ServerReplyPackage servReplyPkg)
{
IRadioMessageIncomming replyInterface = servReplyPkg.Active_RadioMessageIncomming();
_mclLayerProcessor.RadioTransferMessageRecived(replyInterface.RadioPkg as C2CRadioPackage);
}
