// Сигнал для станции об окончании звонка
protected virtual void OnApeCallEnded(CallEventArgs e)
{
if (ApeCallEnded != null)
{
ApeCallEnded(this, e);
}
}
/// <summary>
/// Handles the Received event of the CallHandler_IM control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="FastHelpClient.Data.Events.CallEventArgs"/> instance containing the event data.</param>
protected override void CallHandler_IM_Received(object sender, CallEventArgs e)
{
if (e.MenuName == "#")
{
this.NavigateToMainMenu(false);
}
}
protected void OutgoingCallAccepted(object sender, CallEventArgs e)
{
//Debug.WriteLine("[Port.OutgoingCallAccepted] PortId: {0}", PortId);
//Debug.WriteLine(e);
OnCallAccepted(e);
}
public Phone()
{
Connection = new CallEventArgs()
{
SourcePhoneNumber = String.Empty, AimedPhoneNumber = String.Empty, State = CallState.Unanswered
};
}
public void IncomingCall(object sender, CallEventArgs callEventArgs)
{
bool k = true;
Console.WriteLine("Incoming call from number: {0} to number: {1}", callEventArgs.PhoneNumber, callEventArgs.TargetPhoneNumber);
while (k)
{
Console.WriteLine("Answer? Y/N");
char f = Console.ReadKey().KeyChar;
if (f == 'Y' || f == 'y')
{
k = false;
Console.WriteLine();
if (callEventArgs.PhoneNumber != callEventArgs.TargetPhoneNumber)
{
AnswerToCall(callEventArgs.PhoneNumber, callEventArgs.TargetPhoneNumber, CallState.Answered);
}
else
{
Console.WriteLine("You can not call yourself");
}
}
else if (f == 'N' || f == 'n')
{
k = false;
Console.WriteLine();
EndCall();
}
else
{
Console.WriteLine();
}
}
}
protected virtual void OnCallAccepted(CallEventArgs e)
{
if (CallAccepted != null)
{
CallAccepted(this, e);
}
}
protected void OutgoingCallAccepted(object sender, CallEventArgs e)
{
//Debug.WriteLine("[Terminal.OutgoingCallAccepted]");
//Debug.WriteLine(e);
_call = (CallEventArgs)e.Clone();
}
private void Sender_CallEvent(object src, CallEventArgs args)
{
if (args.Type == CallEventType.ConfigurationComplete)
{
Debug.Log("sender: configuration done. Listening on address " + BenchmarkConfig.Address);
sender.Call(BenchmarkConfig.Address);
}
else if (args.Type == CallEventType.ConfigurationFailed)
{
Debug.LogError("sender: failed to access the audio device");
}
else if (args.Type == CallEventType.ConnectionFailed)
{
mIsActive = false;
Debug.LogError("sender: failed to connect");
}
else if (args.Type == CallEventType.CallAccepted)
{
Debug.Log("sender CallAccepted");
CallAcceptedEventArgs ev = args as CallAcceptedEventArgs;
mToEcho = ev.ConnectionId;
mIsActive = true;
mStartTime = DateTime.Now;
}
else if (args.Type == CallEventType.CallEnded)
{
Debug.Log("sender: received CallEnded event");
mIsActive = false;
}
else if (args.Type == CallEventType.DataMessage)
{
var margs = args as DataMessageEventArgs;
OnMessageReceived(margs.Content);
}
}
private void Sender_CallEvent(object src, CallEventArgs args)
{
if (args.Type == CallEventType.ConfigurationComplete)
{
//STEP6: we got access to media devices
Debug.Log("sender configuration done. Listening on address " + address);
sender.Call(address);
}
else if (args.Type == CallEventType.ConfigurationFailed)
{
//STEP6: user might have blocked access?
Debug.LogError("sender failed to access the audio device");
}
else if (args.Type == CallEventType.ConnectionFailed)
{
//This can happen if the signaling connection failed or
//if the direct connection failed e.g. due to firewall
//See FAQ for more info how to find problems that cause this
Debug.LogError("sender failed to connect");
}
else if (args.Type == CallEventType.CallAccepted)
{
//STEP7: Call Accepted
Debug.Log("sender CallAccepted");
}
else if (args.Type == CallEventType.CallEnded)
{
//STEP8: CallEnded. Either network died or
//one of the calls was destroyed/disposed
Debug.Log("sender received CallEnded event");
}
}
/// <summary>
/// 处理来电，短信等推送消息。
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void client_CallEvent(object sender, CallEventArgs args)
{
this.Invoke(new Action(() =>
{
switch (args.Type)
{
case EventType.SINGLE_INCOMING:
break;
case EventType.TEXT_INCOMING:
textBox1.Text += "收到短信:" + args.Text + "\r\n";
break;
case EventType.GROUP_START:
textBox1.Text += "监听通话开始：" + args.ToString() + "\r\n";
break;
case EventType.GROUP_END:
textBox1.Text += "监听通话结束：" + args.ToString() + "\r\n";
break;
case EventType.CALL_INFO:
textBox1.Text += "PTT通话信息:" + args.ToString() + "\r\n";
break;
case EventType.CALL_END:
textBox1.Text += "通话结束:" + args.ToString() + "\r\n";
break;
case EventType.CALL_SUCCESS:
textBox1.Text += "电话拨出结果：" + args.ToString() + "\r\n";
break;
}
}));
}
protected virtual void OnCallLog(CallEventArgs e)
{
if (CallLog != null)
{
CallLog(this, e);
}
}
/// <summary>
/// Event handler for the receiver side.
/// </summary>
/// <param name="src">receiver mCall object</param>
/// <param name="args">event specific arguments</param>
private void Receiver_CallEvent(object src, CallEventArgs args)
{
if (args.Type == CallEventType.ConfigurationComplete)
{
//STEP3: Connect to the previously set signaling server
//and try to listen for incoming calls on the set address.
Debug.Log("receiver configuration done. Listening on address " + address);
receiver.Listen(address);
}
else if (args.Type == CallEventType.WaitForIncomingCall)
{
//STEP4A: Our address is registered with the server now
//we wait for the sender to connect
Debug.Log("receiver is ready to accept incoming calls");
//setup the sender to connect
SenderSetup();
}
else if (args.Type == CallEventType.ListeningFailed)
{
//STEP4B: Alternatively, we failed to listen.
//e.g. due to no internet / server down / address in use
//currently no specific error information are available.
Debug.LogError("receiver failed to listen to the address");
}
else if (args.Type == CallEventType.CallAccepted)
{
//STEP7:
//The sender connected successfully and a direct connection was
//created.
Debug.Log("receiver CallAccepted");
}
}
/// <summary>
/// 响应计数事件
/// </summary>
/// <param name="callArgs"></param>
private void NotifyEventArgs(CallEventArgs callArgs)
{
//调用计数
ManagedThreadPool.QueueUserWorkItem(state =>
{
try
{
var arr = state as ArrayList;
var statusService = arr[0] as ServerStatusService;
var eventArgs = arr[1] as CallEventArgs;
//调用计数服务
statusService.Counter(eventArgs);
//响应消息
MessageCenter.Instance.Notify(eventArgs);
}
catch (Exception ex)
{
//TODO
}
}, new ArrayList {
status, callArgs
});
}
/// <summary>
/// 调用方法
/// </summary>
/// <param name="client"></param>
/// <param name="reqMsg"></param>
/// <returns></returns>
public ResponseMessage CallMethod(IScsServerClient client, RequestMessage reqMsg)
{
//创建Caller;
var caller = CreateCaller(client, reqMsg);
//设置上下文
SetOperationContext(client, caller);
try
{
//处理状态服务
if (reqMsg.ServiceName == typeof(IStatusService).FullName)
{
var s = ParseService(reqMsg);
//调用服务
return(s.CallService(reqMsg));
}
else
{
//创建服务
var service = CreateService(reqMsg);
//启动计时
var watch = Stopwatch.StartNew();
//调用服务
var resMsg = service.CallService(reqMsg);
//停止计时
watch.Stop();
//调用参数
var callArgs = new CallEventArgs
{
Caller = caller,
ElapsedTime = watch.ElapsedMilliseconds,
Count = resMsg.Count,
Error = resMsg.Error,
Value = resMsg.Value
};
//响应计数
NotifyEventArgs(callArgs);
//如果是Json方式调用，则需要处理异常
if (resMsg.IsError && reqMsg.InvokeMethod)
{
resMsg.Error = new ApplicationException(callArgs.Error.Message);
}
return(resMsg);
}
}
finally
{
//初始化上下文
OperationContext.Current = null;
}
}
public void HandleCallEvent(object o, CallEventArgs e)
{
if (IsNumberExist(e.ReceiverNumber) && e.PortOfCaller.Number != e.ReceiverNumber)
{
var item = Ports.Find(x => x.PortStatus == StatusOfPort.Connected && x.CallStatus == StatusOfCall.Avaliable && e.ReceiverNumber == x.Number);
if (item != null)
{
item.GetAnswer(e);
if (e.AnswerStatus == StatusOfAnswer.Answer)
{
Console.WriteLine("Start of call");
item.ChangeCallStatus(StatusOfCall.Busy);
e.PortOfCaller.ChangeCallStatus(StatusOfCall.Busy);
OnGoingCalls.Add(new CallData(e.PortOfCaller, item));
}
else
{
e.PortOfCaller.ATEMessageShow(new MessageFromAteEventArgs("Desclined"));
}
}
else
{
e.PortOfCaller.ATEMessageShow(new MessageFromAteEventArgs("Receiver is busy"));
}
}
else
{
e.PortOfCaller.ATEMessageShow(new MessageFromAteEventArgs("Number is wrong"));
}
}
protected void IncommingCallEnded(object sender, CallEventArgs e)
{
//Debug.WriteLine("[Terminal.IncommingCallEnded]");
//Debug.WriteLine(e);
_call = null;
}
protected virtual void OnCall(CallEventHandler handler, CallEventArgs e, IPortId destPortId)
{
//Debug.WriteLine("[PhoneExchange.OnCall]");
//Debug.WriteLine(e);
if (handler != null)
{
// Только один нужный порт может быть
var destPortHandler = handler.GetInvocationList()
.Where(d => (d.Target as IPort) != null && ((IPort)d.Target).PortId.Equals(destPortId))
.OfType <CallEventHandler>()
.FirstOrDefault();
var invListOthers = handler.GetInvocationList().Where(d => !(d.Target is IPort))
.OfType <CallEventHandler>();
// Вызвать событие только на порту назначения и для всех подписчиков - не портов
if (destPortHandler != null)
{
OnCallLog(e);
destPortHandler(this, e);
}
else
{
e.State = CallEventStates.Invalid;
OnCallLog(e);
}
foreach (var callEventHandler in invListOthers)
{
callEventHandler(this, e);
}
}
}
protected void TerminalCallAccepted(object sender, CallEventArgs e)
{
//Debug.WriteLine("[Port.TerminalCallAccepted] PortId: {0}", PortId);
//Debug.WriteLine(e);
OnApeCallAccepted(e);
}
public void HandleCall(CallEventArgs e)
{
var callerContract = PhoneOperator.Clients
.SelectMany(c => c.Contracts)
.First(c => c.PortId == e.PortId);
var targetContract = PhoneOperator.Clients
.SelectMany(c => c.Contracts)
.First(c => c.PhoneNumber == e.TargetNumber);
if (!CanCallStarted(callerContract, targetContract))
{
return;
}
_connections.Add(new ConnectionModel(callerContract.PhoneNumber, targetContract.PhoneNumber, e.Id));
var targetPort = Station.Ports.First(p => p.Id == targetContract.PortId);
if (targetPort.Status != PortStatus.Connected)
{
return; // Cannot handle connection.
}
targetPort.IncomingCall(e);
}
public void TakeIncomingCall(object sender, CallEventArgs e)
{
bool flag = true;
Console.WriteLine("Have incoming Call at number: {0} to terminal {1}", e.PhoneNumber, e.TargetPhoneNumber);
while (flag == true)
{
Console.WriteLine("Answer? Y/N");
char k = Console.ReadKey().KeyChar;
if (k == 'Y' || k == 'y')
{
flag = false;
Console.WriteLine();
AnswerToCall(e.PhoneNumber, CallState.Answered);
}
else if (k == 'N' || k == 'n')
{
flag = false;
Console.WriteLine();
AnswerToCall(e.PhoneNumber, CallState.Rejected);
}
else
{
flag = true;
Console.WriteLine();
}
}
}
//-------------------------------------------------------------------------------------------------------------------
// Подписки на события от портов
protected void PortCallStarted(object sender, CallEventArgs e)
{
OnCallPermissionCheck(e);
if (!e.IsAllowed)
{
e.State = CallEventStates.Denied;
OnCall(CallEnded, e, e.SourcePortId);
return;
}
var destPort = _ports.FirstOrDefault(p => p.PortId.Equals(e.DestinationPortId));
if (destPort != null)
{
if (destPort.PortState == PortStates.Connected)
{
OnCallStarted(e);
}
else
{
e.State = CallEventStates.Missed;
OnCall(CallEnded, e, e.SourcePortId);
}
}
else
{
// порт назначения не найден, ответ посылается источнику
e.State = CallEventStates.Invalid;
OnCall(CallEnded, e, e.SourcePortId);
}
}
private void Call_CallEvent(object sender, CallEventArgs args)
{
if (args.Type == CallEventType.ConfigurationComplete)
{
//STEP3: configuration completed -> try calling
Call();
}
else if (args.Type == CallEventType.ConfigurationFailed)
{
Error("Accessing audio / video failed");
}
else if (args.Type == CallEventType.ConnectionFailed)
{
Error("ConnectionFailed");
}
else if (args.Type == CallEventType.ListeningFailed)
{
Error("ListeningFailed");
}
else if (args.Type == CallEventType.CallAccepted)
{
//STEP5: We are connected
mState = SimpleCallState.InCall;
Log("Connection established");
}
else if (args.Type == CallEventType.CallEnded)
{
mState = SimpleCallState.Ended;
Log("Call ended.");
}
else if (args.Type == CallEventType.FrameUpdate)
{
//STEP6: until the end of the call we receive frames here
//Note that this is being called after Configure already for local frames even before
//a connection is established!
//This is triggered each video frame for local and remote video images
FrameUpdateEventArgs frameArgs = args as FrameUpdateEventArgs;
if (frameArgs.ConnectionId == ConnectionId.INVALID)
{
bool textureCreated = UnityMediaHelper.UpdateRawImage(_LocalImage, frameArgs.Frame);
if (textureCreated)
{
Texture2D tex = _LocalImage.texture as Texture2D;
Log("Local Texture(s) created " + tex.width + "x" + tex.height + " format: " + frameArgs.Frame.Format);
}
}
else
{
bool textureCreated = UnityMediaHelper.UpdateRawImage(_RemoteImage, frameArgs.Frame);
if (textureCreated)
{
Texture2D tex = _RemoteImage.texture as Texture2D;
Log("Remote Texture(s) created " + tex.width + "x" + tex.height + " format: " + frameArgs.Frame.Format);
}
}
}
}
private void OnCallRecordSend(object sender, CallEventArgs e)
{
IAbonent abonent = _abonentList.FirstOrDefault(a => a.PhoneNumber == e.CallerPhoneNumber);
Call call = new Call(e, abonent.Tariff);
abonent.Balance -= call.Cost;
_callList.Add(call);
}
public void HandleAnswerEvent(object o, CallEventArgs e)
{
Console.WriteLine("Call from {0}", e.PortOfCaller.Number);
Console.WriteLine("Y - to answer");
string answer = Console.ReadLine();
e.SetAnswerStatus(answer);
}
protected void IncommingCallReceived(object sender, CallEventArgs e)
{
//Debug.WriteLine("[Terminal.IncommingCallReceived]");
//Debug.WriteLine(e);
_call = (CallEventArgs)e.Clone();
OnCallReceived(e);
}
protected void PortCallAccepted(object sender, CallEventArgs e)
{
var destPort = _ports.FirstOrDefault(p => p.PortId.Equals(e.SourcePortId));
if (destPort != null)
{
OnCallAccepted(e);
}
}
public Call(CallEventArgs e, ITariff tariff)
{
CallerPhoneNumber = e.CallerPhoneNumber;
TargetPhoneNumber = e.TargetPhoneNumber;
ResponseCode = e.ResponseCode;
ErrorCode = e.ErrorCode;
DateTimeBegin = e.DateTimeBeginCall;
Duration = (e.DataTimeEndCall - e.DateTimeBeginCall).TotalSeconds;
Cost = Duration * (tariff.CostPerMinute / 10);
}
public CallErrorCode Call(string targetPhoneNumber)
{
var eventArgs = new CallEventArgs(targetPhoneNumber);
eventArgs.DateTimeBeginCall = DateTime.Now;
Called?.Invoke(this, eventArgs);
return(eventArgs.ErrorCode);
}
protected virtual void OnCallPermissionCheck(CallEventArgs e)
{
if (CallPermissionCheck != null)
{
CallPermissionCheck(this, e);
}
else
{
e.IsAllowed = true;
}
}
private static void ClientOnIncomingCall(object sender, CallEventArgs e)
{
try
{
Console.WriteLine($"Incoming call. Sending notification to {_telegramTarget}");
var result = _bot.SendTextMessageAsync(_telegramTarget, $"New Call from {e.CallerName}").Result;
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
