public AnswerEventArgs(int number, int target, CallState state, Guid id)
{
TelephoneNumber = number;
TargetTelephoneNumber = target;
StateInCall = state;
Id = id;
}
public override void OnCallStateChanged(CallState state, string incomingNumber)
{
if (Idle != null && state == CallState.Idle)
Idle(this, null);
else if (IncomingCall != null && state == CallState.Ringing)
IncomingCall(this, incomingNumber);
}
public async Task<AuthorizationResult> AcquireAuthorizationAsync(Uri authorizationUri, Uri redirectUri, IDictionary<string, string> additionalHeaders, CallState callState)
{
returnedUriReady = new SemaphoreSlim(0);
Authenticate(authorizationUri, redirectUri, additionalHeaders, callState);
await returnedUriReady.WaitAsync().ConfigureAwait(false);
return authorizationResult;
}
public void CallbackTest()
{
var counter = 0;
Logger logger = new Logger();
CallState state = new CallState(Guid.NewGuid());
IMsalLogCallback callback = Substitute.For<IMsalLogCallback>();
callback.When(x => x.Log(LogLevel.Error, Arg.Any<string>())).Do(x=>counter++);
LoggerCallbackHandler.Callback = callback;
logger.Error(state, new Exception("test message"));
Assert.AreEqual(1, counter);
callback = Substitute.For<IMsalLogCallback>();
callback.When(x => x.Log(LogLevel.Information, Arg.Any<string>())).Do(x => counter++);
LoggerCallbackHandler.Callback = callback;
logger.Information(state, "test message");
Assert.AreEqual(2, counter);
callback = Substitute.For<IMsalLogCallback>();
callback.When(x => x.Log(LogLevel.Verbose, Arg.Any<string>())).Do(x => counter++);
LoggerCallbackHandler.Callback = callback;
logger.Verbose(state, "test message");
Assert.AreEqual(3, counter);
callback = Substitute.For<IMsalLogCallback>();
callback.When(x => x.Log(LogLevel.Warning, Arg.Any<string>())).Do(x => counter++);
LoggerCallbackHandler.Callback = callback;
logger.Warning(state, "test message");
Assert.AreEqual(4, counter);
}
/// <summary>
/// <para>Completes the operation and invokes the callback, if a callback exists.</para>
/// </summary>
/// <param name="wasSynchronous">
/// <para><see langword="true"/> if the operation completed synchronously;
/// <see langword="false"/> otherwise.</para>
/// </param>
public void CompleteOperation(bool wasSynchronous)
{
_callState = wasSynchronous ? CallState.CompletedSync : CallState.CompletedAsync;
Thread.MemoryBarrier();
_handle.Set();
_callback(this);
}
public async Task<AuthorizationResult> AcquireAuthorizationAsync(Uri authorizationUri, Uri redirectUri, IDictionary<string, string> additionalHeaders, CallState callState)
{
bool ssoMode = ReferenceEquals(redirectUri, Constant.SsoPlaceHolderUri);
WebAuthenticationResult webAuthenticationResult;
WebAuthenticationOptions options = (this.useCorporateNetwork && (ssoMode || redirectUri.Scheme == Constant.MsAppScheme)) ? WebAuthenticationOptions.UseCorporateNetwork : WebAuthenticationOptions.None;
try
{
if (ssoMode)
{
webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(options, authorizationUri).AsTask().ConfigureAwait(false);
}
else
{
webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(options, authorizationUri, redirectUri).AsTask().ConfigureAwait(false);
}
}
catch (Exception ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.AuthenticationUiFailed, ex);
}
AuthorizationResult result = ProcessAuthorizationResult(webAuthenticationResult, callState);
return result;
}
public async Task<AuthorizationResult> AcquireAuthorizationAsync(Uri authorizationUri, Uri redirectUri, IDictionary<string, string> additionalHeaders, CallState callState)
{
AuthorizationResult authorizationResult = null;
StringBuilder builder = new StringBuilder();
if (additionalHeaders != null)
{
bool isFirst = true;
foreach (var key in additionalHeaders.Keys)
{
if (!isFirst)
{
builder.Append("\r\n");
}
builder.AppendFormat("{0}: {1}", key, additionalHeaders[key]);
isFirst = false;
}
}
var sendAuthorizeRequest = new Action(
delegate
{
authorizationResult = this.Authenticate(authorizationUri, redirectUri, builder.ToString());
});
// If the thread is MTA, it cannot create or communicate with WebBrowser which is a COM control.
// In this case, we have to create the browser in an STA thread via StaTaskScheduler object.
if (Thread.CurrentThread.GetApartmentState() == ApartmentState.MTA)
{
using (var staTaskScheduler = new StaTaskScheduler(1))
{
try
{
Task.Factory.StartNew(sendAuthorizeRequest, CancellationToken.None, TaskCreationOptions.None, staTaskScheduler).Wait();
}
catch (AggregateException ae)
{
PlatformPlugin.Logger.Error(callState, ae.InnerException);
// Any exception thrown as a result of running task will cause AggregateException to be thrown with
// actual exception as inner.
Exception innerException = ae.InnerExceptions[0];
// In MTA case, AggregateException is two layer deep, so checking the InnerException for that.
if (innerException is AggregateException)
{
innerException = ((AggregateException)innerException).InnerExceptions[0];
}
throw innerException;
}
}
}
else
{
sendAuthorizeRequest();
}
return await Task.Factory.StartNew(() => authorizationResult).ConfigureAwait(false);
}
public override void OnCallStateChanged(CallState state, string incomingNumber)
{
if (state == CallState.Ringing) {
ShowNotification("Incommming call detected from " + incomingNumber);
base.OnCallStateChanged (state, incomingNumber);
}
}
public void BeginClientMetricsRecord(CallState callState)
{
if (callState != null)
{
metricsTimer = Stopwatch.StartNew();
}
}
public virtual Uri ValidateRedirectUri(Uri redirectUri, CallState callState)
{
if (redirectUri == null)
{
throw new ArgumentNullException("redirectUri");
}
return redirectUri;
}
public CallHistoryInfo(DialInfo caller, DialInfo callee, bool isIncoming, CallState callState, string reasonOfState)
{
Date = DateTime.Now;
PhoneLine = caller;
OtherParty = callee;
IsIncoming = isIncoming;
CallState = callState;
ReasonOfState = reasonOfState;
}
public CallHandler(SIPApp app, Preferences settings, MultimediaHandler mediaHandler, int localAudioPort, int localVideoPort)
{
_app = app;
_settings = settings;
_mediaHandler = mediaHandler;
_localAudioPort = localAudioPort;
_localVideoPort = localVideoPort;
CallState = CallState.Inactive;
}
public CallInfo()
{
this.CallIndex = -1;
this.Dir = CallDir.unknown;
this.Status = CallState.unknown;
this.CallMode = CallMode.unknownn;
this.IsMultipartyConferenceCall = false;
this.Number = this.EntryInPhonebook = "-1";
this.NumberType = CallNumberType.unknown;
}
internal static async Task<UserRealmDiscoveryResponse> CreateByDiscoveryAsync(string userRealmUri, string userName, CallState callState)
{
string userRealmEndpoint = userRealmUri;
userRealmEndpoint += (userName + "?api-version=1.0");
PlatformPlugin.Logger.Information(callState, string.Format("Sending user realm discovery request to '{0}'", userRealmEndpoint));
var client = new MsalHttpClient(userRealmEndpoint, callState) { Client = { Accept = "application/json" } };
return await client.GetResponseAsync<UserRealmDiscoveryResponse>(ClientMetricsEndpointType.UserRealmDiscovery).ConfigureAwait(false);
}
public void Authenticate(Uri authorizationUri, Uri redirectUri, IDictionary<string, string> additionalHeaders, CallState callState)
{
try
{
this.parameters.CallerViewController.PresentViewController(new AuthenticationAgentUINavigationController(authorizationUri.AbsoluteUri, redirectUri.OriginalString, additionalHeaders, CallbackMethod), false, null);
}
catch (Exception ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.AuthenticationUiFailed, ex);
}
}
/// <summary>
/// Parse a parameter from FreeSWITCH
/// </summary>
/// <param name="name">Parameter name as defined by FS</param>
/// <param name="value">Parameter value</param>
/// <returns>
/// true if parsed sucessfully; otherwise false.
/// </returns>
public override bool ParseParameter(string name, string value)
{
switch (name)
{
case "original-channel-call-state":
OriginalChannelCallState = Enumm.Parse<CallState>(value);
break;
default:
return base.ParseParameter(name, value);
}
return true;
}
public Dictionary<string, string> GetPreviousRequestRecord(CallState callState)
{
Dictionary<string, string> parameters;
if (callState != null)
{
parameters = GetClientMetricsParameters();
}
else
{
parameters = new Dictionary<string, string>();
}
return parameters;
}
/// <summary>
/// Parse a parameter from FreeSWITCH
/// </summary>
/// <param name="name">Parameter name as defined by FS</param>
/// <param name="value">Parameter value</param>
/// <returns>
/// true if parsed sucessfully; otherwise false.
/// </returns>
public override bool ParseParameter(string name, string value)
{
switch (name)
{
case "original-channel-call-state":
OriginalChannelCallState = Enumm.Parse <CallState>(value);
break;
default:
return(base.ParseParameter(name, value));
}
return(true);
}
public IWaveProvider Call(IWaveIn waveIn)
{
Reset();
var sampleRate = waveIn.WaveFormat.SampleRate;
state = CallState.WaitForAnswer;
toneDetector = new BiFSKDetector(sampleRate, Channel2Freq);
toneDetector.DetectTone += ToneDetected;
toneGenerator = new ToneGenerator(sampleRate, Channel1Freq);
ansamDetector = new ANSamDetector(sampleRate);
ansamDetector.DetectANSam += ANSamDetected;
waveIn.DataAvailable += WaveInDataAvailable;
return(toneGenerator);
}
public static T CreateResponse <T>(HttpResponse response, CallState callState, bool addCorrelationId)
{
if (response.StatusCode != HttpStatusCode.OK)
{
CreateErrorResponse(response, callState);
}
if (addCorrelationId)
{
VerifyCorrelationIdHeaderInReponse(response.Headers, callState);
}
return(JsonHelper.DeserializeFromJson <T>(response.Body));
}
internal override void HandleResourceEvent(EventContext eventcontext)
{
CallState oldState = State;
// Raise resource events before CallStateChanged event
base.HandleResourceEvent(eventcontext);
CallState newState = State;
if (oldState != newState)
{
m_callStateChanged?.Invoke(this, new CallStateChangedEventArgs(oldState, State));
}
}
public static bool FalseCall(Vector3 position, string calloutName)
{
if (Vector3.Distance(Game.LocalPlayer.Character.Position, position) < 30f && callState == CallState.Start)
{
callState = CallState.Middle;
calloutName.DisplayNotification("Caller hung up, investigate the area");
}
if (Vector3.Distance(Game.LocalPlayer.Character.Position, position) < 10f && callState == CallState.Middle)
{
callState = CallState.Wait;
GameFiber.StartNew(delegate
{
GameFiber.Sleep(Fiskey111Common.Rand.RandomNumber(9000));
GameFiber.Sleep(Fiskey111Common.Rand.RandomNumber(4000, 9000));
GameFiber.Sleep(Fiskey111Common.Rand.RandomNumber(4000, 9000));
GameFiber.Sleep(Fiskey111Common.Rand.RandomNumber(4000, 9000));
calloutName.DisplayNotification("Update: Call possibly false\nInvestigate the area");
});
}
if (callState == CallState.Wait && !_wait)
{
_wait = true;
if (Fiskey111Common.Rand.RandomNumber(1, 10) == 1)
{
_p = new Ped(position);
if (Fiskey111Common.Rand.RandomNumber(1, 4) == 1)
{
Weapon g = new Weapon("WEAPON_PISTOL", position, 100);
g.GiveTo(_p);
}
_p.KeepTasks = true;
_p.Tasks.FightAgainst(Game.LocalPlayer.Character, -1);
callState = CallState.End;
}
else
{
GameFiber.Sleep(Fiskey111Common.Rand.RandomNumber(3000, 9000));
calloutName.DisplayNotification("Call determined to be a false report");
return(true);
}
}
if (callState == CallState.End && (_p.IsDead || Functions.IsPedArrested(_p)))
{
return(true);
}
GameFiber.Yield();
return(false);
}
public SessionScriptBase(RbrResult pInitResult, ISession pSession, ScriptInfo pScriptInfo)
{
session = pSession;
scriptInfo = pScriptInfo;
promptManager = new PromptManager(scriptInfo);
leg1Length = 0;
cardLength = scriptInfo.PinLength;
neverUsed = false;
startingBalance = currentBalance = decimal.Zero;
currentBonusBalance = 0;
serialNumber = string.Empty;
callState = CallState.Initializing;
}
public override void OnCallStateChanged(CallState state, string incomingNumber)
{
base.OnCallStateChanged(state, incomingNumber);
switch(state) {
case CallState.Ringing:
case CallState.Offhook:
// stop media player
PortaPodderApp.Context.StopService(new Intent(PortaPodderApp.Context, typeof(EpisodePlayer)));
break;
case CallState.Idle:
default:
// intentionally do nothing
break;
}
}
public void TestInstanceDiscovery_WhenMultipleSimultaneousCallsWithTheSameAuthority_ShouldMakeOnlyOneRequest()
{
for (int i = 0; i < 2; i++) // Prepare 2 mock responses
{
HttpMessageHandlerFactory.AddMockHandler(MockHelpers.CreateInstanceDiscoveryMockHandler("https://login.windows.net/common/discovery/instance"));
}
CallState callState = new CallState(Guid.NewGuid());
string host = "login.windows.net";
Task.WaitAll( // Simulate several simultaneous calls
InstanceDiscovery.GetMetadataEntry(new Uri($"https://{host}/tenant"), true, callState),
InstanceDiscovery.GetMetadataEntry(new Uri($"https://{host}/tenant"), true, callState));
Assert.AreEqual(1, HttpMessageHandlerFactory.MockHandlersCount()); // 1 mock response is consumed, 1 remaining
}
private static async Task <HttpResponse> ExecuteWithRetry(Uri endpoint, Dictionary <string, string> headers,
Dictionary <string, string> bodyParameters, HttpMethod method,
CallState callstate, bool retry = true)
{
bool isRetryable = false;
HttpResponse response = null;
try
{
response = await Execute(endpoint, headers, bodyParameters, method);
if (response.StatusCode == HttpStatusCode.OK)
{
return(response);
}
PlatformPlugin.Logger.Error(callstate,
string.Format(CultureInfo.InvariantCulture,
"Response status code does not indicate success: {0} ({1}).",
(int)response.StatusCode, response.StatusCode));
if ((response.StatusCode.Equals(HttpStatusCode.InternalServerError)) ||
(response.StatusCode).Equals(HttpStatusCode.GatewayTimeout) ||
(response.StatusCode).Equals(HttpStatusCode.ServiceUnavailable))
{
isRetryable = true;
}
}
catch (TaskCanceledException exception)
{
PlatformPlugin.Logger.Error(callstate, exception);
isRetryable = true;
}
if (isRetryable)
{
if (retry)
{
PlatformPlugin.Logger.Information(callstate, "Retrying one more time..");
return(await ExecuteWithRetry(endpoint, headers, bodyParameters, method, callstate, false));
}
PlatformPlugin.Logger.Information(callstate, "Request retry failed.");
throw new RetryableRequestException();
}
return(response);
}
/// <summary>
/// Parse a delimited string of key-value pairs in to a dictionary.
/// </summary>
/// <param name="input">Delimited string of key-value pairs</param>
/// <param name="delimiter">Character used as a delimiter between key-value pairs</param>
/// <param name="urlDecode">True to perform URL decoding of both the keys and values</param>
/// <param name="lowercaseKeys">True to make all resulting keys lower-case</param>
/// <param name="callState">call state to pass correlation id and logger instance</param>
/// <param name="strict">Throw <see cref="ArgumentException"/> when the input string contains a malformed key-value pair</param>
/// <exception cref="ArgumentException">Thrown if <paramref name="strict"/> is true and a malformed key-value pair is present in <paramref name="input"/></exception>
/// <returns>Dictionary of string key-value pairs</returns>
private static Dictionary <string, string> ParseKeyValueList(string input, char delimiter, bool urlDecode, bool lowercaseKeys,
CallState callState, bool strict)
{
var response = new Dictionary <string, string>();
List <string> queryPairs = SplitWithQuotes(input, delimiter);
foreach (string queryPair in queryPairs)
{
List <string> pair = SplitWithQuotes(queryPair, '=');
if (pair.Count == 2 && !string.IsNullOrWhiteSpace(pair[0]) && !string.IsNullOrWhiteSpace(pair[1]))
{
string key = pair[0];
string value = pair[1];
// Url decoding is needed for parsing OAuth response, but not for parsing WWW-Authenticate header in 401 challenge
if (urlDecode)
{
key = UrlDecode(key);
value = UrlDecode(value);
}
if (lowercaseKeys)
{
key = key.Trim().ToLowerInvariant();
}
value = value.Trim().Trim(new[] { '\"' }).Trim();
if (response.ContainsKey(key) && callState != null)
{
var msg = string.Format(CultureInfo.CurrentCulture,
"Key/value pair list contains redundant key '{0}'.", key);
callState.Logger.Warning(callState, msg);
callState.Logger.WarningPii(callState, msg);
}
response[key] = value;
}
else if (strict && pair.Count > 2)
{
throw new ArgumentException(nameof(input));
}
}
return(response);
}
private static Activity GenerateActivity(string text, CallState callState)
{
var thisParticipant = callState.Participants.Single(t => t.Originator);
return(new Activity
{
ChannelId = "directline",
Conversation = new ConversationAccount(id: callState.Conversation.ConversationId),
From = new ChannelAccount(id: thisParticipant.Identity, name: thisParticipant.DisplayName),
Id = callState.Conversation.ConversationId + "|" + (int.Parse(callState.Watermark) + 1).ToString("D7"),
Locale = thisParticipant.LanguageId,
Text = text,
Type = ActivityTypes.Message,
ServiceUrl = ConfigurationManager.AppSettings["Microsoft.Bot.Builder.Calling.CallbackUrl"]
});
}
public Channel CallTo(string dst)
{
try
{
agent = pbx.Channels.Originate(dst, null, null, null, null, appName, "", "1111", 20, null, null, null, null);
callState = CallState.CONNECTIING;
chronometer.CallToStart();
//bridge.Channels.Add(agent.Id); //no debería hacerlo cuando es calltosuccess?
}
catch (Exception ex)
{
throw new Exception("Error llamando a: " + dst, ex);
}
return(agent);
}
private string ConvertState(CallState state)
{
switch (state)
{
case CallState.ACTIVE: return("Active");
case CallState.ALERTING:
case CallState.CONNECTING: return("Calling");
case CallState.INCOMING: return("Incoming");
case CallState.HOLDING: return("Holding");
default: return("Ended");
}
}
private void UpdateComponent()
{
this.friendNumber = -1;
this.friendName = string.Empty;
this.friendStatusMessage = string.Empty;
this.latestFriendMessage = null;
this.latestFriendAction = null;
this.latestFriendActivityDate = ZeroDateTime;
this.friendTypingStatus = false;
this.callState = CallState.None;
this.displayName.DoubleClick += this.OnFriendInfoDoubleClick;
this.displayStatusMessage.DoubleClick += this.OnFriendInfoDoubleClick;
this.startCall.PictureClick += this.OnStartCallClick;
this.endCall.PictureClick += this.OnEndCallClick;
this.removeEntry.PictureClick += this.OnRemoveEntryClick;
this.UpdateControl();
}
private static void CallStatusUpdated(CallState state)
{
switch (state)
{
case CallState.Ringing:
LedSdkAbstraction.FlashLighting(currentSdk, 0, 0, 100, 120000, 200);
break;
case CallState.Connected:
LedSdkAbstraction.PulseLighting(currentSdk, 100, 0, 0, 0, 800); //duration == 0 is infinite for Logitech.
break;
case CallState.NoUpdate:
SetLEDToCurrentStatus(LyncStatusWatcher.UserStatus);
break;
}
}
public void PiiLogCallbackTest()
{
var logger = new Logger();
var state = new CallState(Guid.NewGuid());
var obsoleteCallback = new TestObsoleteAdalLogCallback();
LoggerCallbackHandler.Callback = obsoleteCallback;
LoggerCallbackHandler.LogCallback = InitLogCallback();
LoggerCallbackHandler.PiiLoggingEnabled = true;
logger.ErrorPii(state, new Exception(Message));
Assert.AreEqual(1, _piiErrorLogCount);
Assert.AreEqual(0, _piiWarningLogCount);
Assert.AreEqual(0, _piiInfoLogCount);
Assert.AreEqual(0, _piiVerboseLogCount);
logger.InformationPii(state, Message);
Assert.AreEqual(1, _piiErrorLogCount);
Assert.AreEqual(0, _piiWarningLogCount);
Assert.AreEqual(1, _piiInfoLogCount);
Assert.AreEqual(0, _piiVerboseLogCount);
logger.VerbosePii(state, Message);
Assert.AreEqual(1, _piiErrorLogCount);
Assert.AreEqual(0, _piiWarningLogCount);
Assert.AreEqual(1, _piiInfoLogCount);
Assert.AreEqual(1, _piiVerboseLogCount);
logger.WarningPii(state, Message);
Assert.AreEqual(1, _piiErrorLogCount);
Assert.AreEqual(1, _piiWarningLogCount);
Assert.AreEqual(1, _piiInfoLogCount);
Assert.AreEqual(1, _piiVerboseLogCount);
// make sure no calls to Log with containsPii = false
Assert.AreEqual(0, _errorLogCount);
Assert.AreEqual(0, _warningLogCount);
Assert.AreEqual(0, _infoLogCount);
Assert.AreEqual(0, _verboseLogCount);
// make sure no calls were done to ObsoleteAdalLogCallback
Assert.AreEqual(0, obsoleteCallback.AllCallsCount);
}
public static void CreateErrorResponse(HttpResponse response, CallState callState)
{
MsalServiceException serviceEx;
try
{
TokenResponse tokenResponse = JsonHelper.DeserializeFromJson <TokenResponse>(response.Body);
serviceEx = new MsalServiceException(tokenResponse.Error, tokenResponse.ErrorDescription);
}
catch (SerializationException)
{
serviceEx = new MsalServiceException(MsalError.Unknown, response.Body);
}
PlatformPlugin.Logger.Error(callState, serviceEx);
throw serviceEx;
}
public void Authenticate(Uri authorizationUri, Uri redirectUri, CallState callState)
{
try
{
safariViewController = new SFSafariViewController(new NSUrl(authorizationUri.AbsoluteUri), false);
safariViewController.Delegate = this;
this.parameters.CallerViewController.InvokeOnMainThread(() =>
{
this.parameters.CallerViewController.PresentViewController(safariViewController, false, null);
});
}
catch (Exception ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.AuthenticationUiFailed, ex);
}
}
public void EndClientMetricsRecord(string endpoint, CallState callState)
{
if (callState != null && metricsTimer != null)
{
metricsTimer.Stop();
lastResponseTime = metricsTimer.ElapsedMilliseconds;
lastCorrelationId = callState.CorrelationId;
lastEndpoint = endpoint;
lock (PendingClientMetricsLock)
{
if (pendingClientMetrics == null)
{
pendingClientMetrics = this;
}
}
}
}
void AsyncCallCallback(IAsyncResult result)
{
CallState cs = (CallState)result.AsyncState;
Response data = cs.client.EndGetUserRoles(result);
List <string[]> claimData = new List <string[]>();
foreach (var val in data.Values)
{
claimData.Add(new string[1] {
val
});
}
string[][] retVal = claimData.ToArray();
TypedAsyncResult <string[][]> queryResult = (TypedAsyncResult <string[][]>)cs.result;
queryResult.Complete(retVal, false);
}
public void OnCallCompleted(CallState pLastCallState)
{
lock (padlock) {
if (pLastCallState == CallState.Started)
{
currentOpen--;
}
if (pLastCallState == CallState.Connecting)
{
currentConnecting--;
}
if (pLastCallState == CallState.Connected)
{
currentConnected--;
}
}
}
public DTypeDesc /*!*/ PeekType(int i)
{
if (TypeArgCount >= i)
{
// peeks the value:
return(Types[TypesTop - i]);
}
else
{
// warning (can invoke user code => we have to save and restore callstate):
CallState call_state = SaveCallState();
PhpException.MissingTypeArgument(i, CalleeName);
RestoreCallState(call_state);
return(DTypeDesc.ObjectTypeDesc);
}
}
public void ObsoleteAdalLogCallbackTest()
{
var logger = new Logger();
var state = new CallState(Guid.NewGuid());
var obsoleteCallback = new TestObsoleteAdalLogCallback();
LoggerCallbackHandler.Callback = obsoleteCallback;
LoggerCallbackHandler.LogCallback = null;
LoggerCallbackHandler.PiiLoggingEnabled = true;
logger.ErrorPii(state, new Exception(Message));
logger.InformationPii(state, Message);
logger.VerbosePii(state, Message);
logger.WarningPii(state, Message);
// make sure no Pii are logged with ObsoleteAdalLogCallback
Assert.AreEqual(0, obsoleteCallback.AllCallsCount);
logger.Error(state, new Exception(Message));
Assert.AreEqual(1, obsoleteCallback.ErrorLogCount);
Assert.AreEqual(0, obsoleteCallback.WarningLogCount);
Assert.AreEqual(0, obsoleteCallback.InfoLogCount);
Assert.AreEqual(0, obsoleteCallback.VerboseLogCount);
logger.Information(state, Message);
Assert.AreEqual(1, obsoleteCallback.ErrorLogCount);
Assert.AreEqual(0, obsoleteCallback.WarningLogCount);
Assert.AreEqual(1, obsoleteCallback.InfoLogCount);
Assert.AreEqual(0, obsoleteCallback.VerboseLogCount);
logger.Verbose(state, Message);
Assert.AreEqual(1, obsoleteCallback.ErrorLogCount);
Assert.AreEqual(0, obsoleteCallback.WarningLogCount);
Assert.AreEqual(1, obsoleteCallback.InfoLogCount);
Assert.AreEqual(1, obsoleteCallback.VerboseLogCount);
logger.Warning(state, Message);
Assert.AreEqual(1, obsoleteCallback.ErrorLogCount);
Assert.AreEqual(1, obsoleteCallback.WarningLogCount);
Assert.AreEqual(1, obsoleteCallback.InfoLogCount);
Assert.AreEqual(1, obsoleteCallback.VerboseLogCount);
}
public void GetUserCallsByCallStatePerMonth(IUser user, CallState callState)
{
var userCalls = Calls
.Where(x => User.Equals(user) && x.GetStarted().Date >= DateTime.Now.AddMonths(-1).Date&& x.GetCallState().Equals(callState));
if (userCalls.Count() == 0)
{
Console.WriteLine($"No {callState} calls");
}
else
{
Console.WriteLine($"{callState} calls");
foreach (var item in userCalls.OrderBy(x => x.GetStarted()))
{
Console.WriteLine($"{item}\n");
}
}
}
public object PeekValueUnchecked(int i)
{
PhpRuntimeChain php_chain;
// caller may have pushed a reference even if a formal argument is not reference => dereference it:
object result = PhpVariable.Dereference(Items[Top - i]);
// caller may have pushed a runtime chain => evaluate it:
if ((php_chain = result as PhpRuntimeChain) != null)
{
// call state has to be stored since chain can call arbitrary user code:
CallState call_state = SaveCallState();
result = php_chain.GetValue(Context);
RestoreCallState(call_state);
}
return(result);
}
public void NullCallbackTest()
{
var logger = new Logger();
var state = new CallState(Guid.NewGuid());
LoggerCallbackHandler.Callback = null;
LoggerCallbackHandler.LogCallback = null;
logger.Error(state, new Exception(Message));
logger.Information(state, Message);
logger.Verbose(state, Message);
logger.Warning(state, Message);
logger.ErrorPii(state, new Exception(Message));
logger.InformationPii(state, Message);
logger.VerbosePii(state, Message);
logger.WarningPii(state, Message);
}
private void CallStateChangedHandler(object sender, VoIPEventArgs <CallState> e)
{
CallState callState = e.Item;
_log.Debug("State change to " + callState.ToString());
if (callState == CallState.InCall)
{
CallAnswered();
}
else if (callState == CallState.Completed)
{
CallEnded();
}
else
{
_log.Debug("Unhandled call state " + callState.ToString());
}
}
void setConnected(string pDestIPAddress)
{
cdr.Leg2Start();
var _result = sessionHandler.CallConnect(session.Id,
session.AccessNumber,
session.OrigIPAddress,
pDestIPAddress,
LegIn.CustomerAcctId,
LegIn.CustomerRouteId,
legOutOptions[outboundAttempt - 1].CarrierAcctId,
legOutOptions[outboundAttempt - 1].CarrierBaseRouteId,
cdr.Leg1Length);
if (_result)
{
callState = sessionHandler.OnConnected(legOutOptions[outboundAttempt - 1].CarrierAcctId, LegIn.CustomerAcctId);
}
}
public override void OnCallStateChanged([GeneratedEnum] CallState state, string incomingNumber)
{
if (state == CallState.Offhook)
{
if (_Recorder != null)
{
_Recorder.RecStart();
}
}
else if (state == CallState.Idle)
{
if (_Recorder != null)
{
_Recorder.RecStop(incomingNumber);
_Recorder.Dispose();
}
}
}
private async Task OnIncomingCallReceived(IncomingCallEvent incomingCallEvent)
{
System.Diagnostics.Trace.TraceInformation(DateTime.Now + " CallReceived " + incomingCallEvent.IncomingCall.Id);
var client = new DirectLineClient(directLineSecret);
var conversation = client.Conversations.StartConversation();
string watermark = null;
var callState = new CallState(incomingCallEvent.IncomingCall.Participants, conversation, watermark);
await Task.Delay(1000);
List <ActionBase> actionList = await GetActionListOnIncomingCall(client, callState);
incomingCallEvent.ResultingWorkflow.Actions = actionList;
this.callStateMap[incomingCallEvent.IncomingCall.Id] = callState;
//return Task.FromResult(true);
}
private void OnCall(Core lc, Call lcall, CallState state, string message)
{
try
{
if (state == CallState.End || state == CallState.Error)
{
LastCall = null;
}
if ((state == CallState.IncomingReceived || state == CallState.OutgoingInit) && LastCall != null)
{
linphoneCore.TerminateCall(LastCall);
LastCall = null;
}
if ((state == CallState.IncomingReceived || state == CallState.OutgoingInit) && LastCall == null)
{
LastCall = lcall;
}
CallPCL call = new CallPCL
{
UsernameCaller = lcall.RemoteAddress.Username
};
CallParams param = linphoneCore.CreateCallParams(lcall);
lock (LinphoneListeners)
{
for (int i = 0; i < LinphoneListeners.Count; i++)
{
try
{
var listener = LinphoneListeners[i];
listener.OnCall(new CallArgs(call, (int)state, message, param.VideoEnabled));
}
catch (Exception ex)
{
Log("error with listenner, OnCall");
}
}
}
}
catch (Exception ex) { }
}
public async Task <AuthorizationResult> AcquireAuthorizationAsync(Uri authorizationUri, Uri redirectUri,
CallState callState)
{
AuthorizationResult authorizationResult = null;
var sendAuthorizeRequest = new Action(
delegate { authorizationResult = this.Authenticate(authorizationUri, redirectUri); });
// If the thread is MTA, it cannot create or communicate with WebBrowser which is a COM control.
// In this case, we have to create the browser in an STA thread via StaTaskScheduler object.
if (Thread.CurrentThread.GetApartmentState() == ApartmentState.MTA)
{
using (var staTaskScheduler = new StaTaskScheduler(1))
{
try
{
Task.Factory.StartNew(sendAuthorizeRequest, CancellationToken.None, TaskCreationOptions.None,
staTaskScheduler).Wait();
}
catch (AggregateException ae)
{
PlatformPlugin.Logger.Error(callState, ae.InnerException);
// Any exception thrown as a result of running task will cause AggregateException to be thrown with
// actual exception as inner.
Exception innerException = ae.InnerExceptions[0];
// In MTA case, AggregateException is two layer deep, so checking the InnerException for that.
if (innerException is AggregateException)
{
innerException = ((AggregateException)innerException).InnerExceptions[0];
}
throw innerException;
}
}
}
else
{
sendAuthorizeRequest();
}
return(await Task.Factory.StartNew(() => authorizationResult).ConfigureAwait(false));
}
public static async Task<WsTrustResponse> SendRequestAsync(WsTrustAddress wsTrustAddress, UserCredential credential, CallState callState)
{
HttpClientWrapper request = new HttpClientWrapper(wsTrustAddress.Uri.AbsoluteUri, callState);
request.ContentType = "application/soap+xml";
if (credential.UserAuthType == UserAuthType.IntegratedAuth)
{
SetKerberosOption(request);
}
StringBuilder messageBuilder = BuildMessage(DefaultAppliesTo, wsTrustAddress, credential);
WsTrustResponse wstResponse;
try
{
request.BodyParameters = new StringRequestParameters(messageBuilder);
IHttpWebResponse response = await request.GetResponseAsync().ConfigureAwait(false);
wstResponse = WsTrustResponse.CreateFromResponse(response.ResponseStream, wsTrustAddress.Version);
}
catch (WebException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
string errorMessage;
try
{
XDocument responseDocument = WsTrustResponse.ReadDocumentFromResponse(ex.Response.GetResponseStream());
errorMessage = WsTrustResponse.ReadErrorResponse(responseDocument, callState);
}
catch (MsalException)
{
errorMessage = "See inner exception for detail.";
}
throw new MsalServiceException(
MsalError.FederatedServiceReturnedError,
string.Format(MsalErrorMessage.FederatedServiceReturnedErrorTemplate, wsTrustAddress.Uri, errorMessage),
null,
ex);
}
return wstResponse;
}
public async Task UpdateFromTemplateAsync(CallState callState)
{
if (!this.updatedFromTemplate)
{
var authorityUri = new Uri(this.Authority);
string host = authorityUri.Authority;
string path = authorityUri.AbsolutePath.Substring(1);
string tenant = path.Substring(0, path.IndexOf("/", StringComparison.Ordinal));
AuthenticatorTemplate matchingTemplate = await AuthenticatorTemplateList.FindMatchingItemAsync(this.ValidateAuthority, host, tenant, callState).ConfigureAwait(false);
this.AuthorizationUri = matchingTemplate.AuthorizeEndpoint.Replace("{tenant}", tenant);
this.DeviceCodeUri = matchingTemplate.DeviceCodeEndpoint.Replace("{tenant}", tenant);
this.TokenUri = matchingTemplate.TokenEndpoint.Replace("{tenant}", tenant);
this.UserRealmUri = CanonicalizeUri(matchingTemplate.UserRealmEndpoint);
this.IsTenantless = IsTenantLess(this.Authority);
this.SelfSignedJwtAudience = matchingTemplate.Issuer.Replace("{tenant}", tenant);
this.updatedFromTemplate = true;
}
}
public static Dictionary<string, string> ParseKeyValueList(string input, char delimiter, bool urlDecode, bool lowercaseKeys,
CallState callState)
{
var response = new Dictionary<string, string>();
List<string> queryPairs = SplitWithQuotes(input, delimiter);
foreach (string queryPair in queryPairs)
{
List<string> pair = SplitWithQuotes(queryPair, '=');
if (pair.Count == 2 && !string.IsNullOrWhiteSpace(pair[0]) && !string.IsNullOrWhiteSpace(pair[1]))
{
string key = pair[0];
string value = pair[1];
// Url decoding is needed for parsing OAuth response, but not for parsing WWW-Authenticate header in 401 challenge
if (urlDecode)
{
key = UrlDecode(key);
value = UrlDecode(value);
}
if (lowercaseKeys)
{
key = key.Trim().ToLower();
}
value = value.Trim().Trim(new[] { '\"' }).Trim();
if (response.ContainsKey(key) && callState != null)
{
PlatformPlugin.Logger.Warning(callState, string.Format(CultureInfo.InvariantCulture,"Key/value pair list contains redundant key '{0}'.", key));
}
response[key] = value;
}
}
return response;
}
private static AuthorizationResult ProcessAuthorizationResult(WebAuthenticationResult webAuthenticationResult, CallState callState)
{
AuthorizationResult result;
switch (webAuthenticationResult.ResponseStatus)
{
case WebAuthenticationStatus.Success:
result = new AuthorizationResult(AuthorizationStatus.Success, webAuthenticationResult.ResponseData);
break;
case WebAuthenticationStatus.ErrorHttp:
result = new AuthorizationResult(AuthorizationStatus.ErrorHttp, webAuthenticationResult.ResponseErrorDetail.ToString(CultureInfo.InvariantCulture));
break;
case WebAuthenticationStatus.UserCancel:
result = new AuthorizationResult(AuthorizationStatus.UserCancel, null);
break;
default:
result = new AuthorizationResult(AuthorizationStatus.UnknownError, null);
break;
}
return result;
}
public async Task<AuthorizationResult> AcquireAuthorizationAsync(Uri authorizationUri, Uri redirectUri, IDictionary<string, string> additionalHeaders, CallState callState)
{
returnedUriReady = new SemaphoreSlim(0);
try
{
var agentIntent = new Intent(this.parameters.CallerActivity, typeof(AuthenticationAgentActivity));
agentIntent.PutExtra("Url", authorizationUri.AbsoluteUri);
agentIntent.PutExtra("Callback", redirectUri.AbsoluteUri);
AuthenticationAgentActivity.AdditionalHeaders = additionalHeaders;
this.parameters.CallerActivity.StartActivityForResult(agentIntent, 0);
}
catch (Exception ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.AuthenticationUiFailed, ex);
}
await returnedUriReady.WaitAsync().ConfigureAwait(false);
return authorizationResult;
}
public async Task VerifyAnotherHostByInstanceDiscoveryAsync(string host, string tenant, CallState callState)
{
string instanceDiscoveryEndpoint = this.InstanceDiscoveryEndpoint;
instanceDiscoveryEndpoint += ("?api-version=1.0&authorization_endpoint=" + AuthorizeEndpointTemplate);
instanceDiscoveryEndpoint = instanceDiscoveryEndpoint.Replace("{host}", host);
instanceDiscoveryEndpoint = instanceDiscoveryEndpoint.Replace("{tenant}", tenant);
try
{
var client = new MsalHttpClient(instanceDiscoveryEndpoint, callState);
InstanceDiscoveryResponse discoveryResponse = await client.GetResponseAsync<InstanceDiscoveryResponse>(ClientMetricsEndpointType.InstanceDiscovery).ConfigureAwait(false);
if (discoveryResponse.TenantDiscoveryEndpoint == null)
{
throw new MsalException(MsalError.AuthorityNotInValidList);
}
}
catch (MsalServiceException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException((ex.ErrorCode == "invalid_instance") ? MsalError.AuthorityNotInValidList : MsalError.AuthorityValidationFailed, ex);
}
}
public static string ReadErrorResponse(XDocument responseDocument, CallState callState)
{
string errorMessage = null;
try
{
XElement body = responseDocument.Descendants(XmlNamespace.SoapEnvelope + "Body").FirstOrDefault();
if (body != null)
{
XElement fault = body.Elements(XmlNamespace.SoapEnvelope + "Fault").FirstOrDefault();
if (fault != null)
{
XElement reason = fault.Elements(XmlNamespace.SoapEnvelope + "Reason").FirstOrDefault();
if (reason != null)
{
XElement text = reason.Elements(XmlNamespace.SoapEnvelope + "Text").FirstOrDefault();
if (text != null)
{
using (var reader = text.CreateReader())
{
reader.MoveToContent();
errorMessage = reader.ReadInnerXml();
}
}
}
}
}
}
catch (XmlException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.ParsingWsTrustResponseFailed, ex);
}
return errorMessage;
}
internal static async Task<XDocument> FetchMexAsync(string federationMetadataUrl, CallState callState)
{
XDocument mexDocument;
try
{
HttpClientWrapper request = new HttpClientWrapper(federationMetadataUrl, callState);
using (var response = await request.GetResponseAsync().ConfigureAwait(false))
{
mexDocument = XDocument.Load(response.ResponseStream, LoadOptions.None);
}
}
catch (WebException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalServiceException(MsalError.AccessingWsMetadataExchangeFailed, ex);
}
catch (XmlException ex)
{
PlatformPlugin.Logger.Error(callState, ex);
throw new MsalException(MsalError.ParsingWsMetadataExchangeFailed, ex);
}
return mexDocument;
}
internal void RestoreCallState(CallState old)
{
TypeArgCount = old.TypeCount;
ArgCount = old.ArgCount;
Callback = old.Callback;
CalleeName = old.CalleeName;
Variables = old.Variables;
NamingContext = old.NamingContext;
AllowProtectedCall = old.AllowProtectedCall;
LateStaticBindType = old.LateStaticBindType;
}
private void call_CallStateChanged(object sender, VoIPEventArgs<CallState> e)
{
callstate = e.Item;
if (e.Item == CallState.Ringing)
{
m_TimeStart = DateTime.Now.TimeOfDay;
m_StartTimeOutCounter = true;
m_MediaUtility.Start(MediaUtility.ePhoneCallSoundType.Ring);
}
else if (e.Item == CallState.InCall)
{
try
{
m_StartTimeOutCounter = false;
m_MediaUtility.Stop();
recorder.StartStreaming();
//recorder.IsStreaming = true;
}
catch (Ozeki.Common.Exceptions.MediaException me)
{
if (CallState_Changed != null)
{
AudioId = Guid.Empty;
CallState_Changed(this, new CallStateChangedArgs()
{
PhoneCallState = CallState.Rejected
});
}
if (call != null)
call.HangUp();
//softPhone.UnregisterPhoneLine(phoneLine);
softPhone.Close();
this.WireDownCallEvents();
call = null;
m_MediaUtility.Start(MediaUtility.ePhoneCallSoundType.HangUp);
MessageBox.Show("Your mic or speaker is not working. Please change your mic or speaker in the Phone Settings.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
}
else if (e.Item == CallState.Completed)
{
try
{
recorder.StopStreaming();
//recorder.IsStreaming = false;
EndCall();
if (m_RingTimeOut)
return;
this.WireDownCallEvents();
call = null;
recorder.Dispose();
recorder = null;
CommonApplicationData commonData = new CommonApplicationData("BrightVision", "BrightSales", true);
string fileNameTmp = String.Format(@"{0}\tmpwav\{1}_.wav", commonData.ApplicationFolderPath, AudioId);
string fileNameCache = String.Format(@"{0}\cachewav\{1}_.wav", commonData.ApplicationFolderPath, AudioId);
File.Copy(fileNameTmp, fileNameCache);
m_MediaUtility.Start(MediaUtility.ePhoneCallSoundType.HangUp);
}
catch
{
//softPhone.UnregisterPhoneLine(phoneLine);
softPhone.Close();
this.WireDownCallEvents();
call = null;
}
}
else if (e.Item == CallState.Cancelled)
{
AudioId = Guid.Empty;
EndCall();
if (m_RingTimeOut)
return;
m_StartTimeOutCounter = false;
//softPhone.UnregisterPhoneLine(phoneLine);
this.WireDownCallEvents();
call = null;
m_MediaUtility.Start(MediaUtility.ePhoneCallSoundType.HangUp);
}
else if (e.Item == CallState.Rejected)
{
AudioId = Guid.Empty;
EndCall();
m_StartTimeOutCounter = false;
//softPhone.UnregisterPhoneLine(phoneLine);
this.WireDownCallEvents();
call = null;
m_MediaUtility.Start(MediaUtility.ePhoneCallSoundType.HangUp);
}
else if (e.Item == CallState.Busy || e.Item == CallState.Error)
{
AudioId = Guid.Empty;
EndCall();
m_RingTimeOut = true;
m_StartTimeOutCounter = false;
m_MediaUtility.Start(MediaUtility.ePhoneCallSoundType.Busy);
//softPhone.UnregisterPhoneLine(phoneLine);
softPhone.Close();
call.HangUp();
call = null;
//MessageBox.Show("Error encountered. Please check the format of the number you are calling.", "Bright Sales", MessageBoxButtons.OK, MessageBoxIcon.Information);
//this.WireDownCallEvents();
//call = null;
}
if (CallState_Changed != null)
{
CallState_Changed(this, new CallStateChangedArgs()
{
PhoneCallState = e.Item,
AudioId = AudioId
});
}
}
/// <summary>
/// Displays call state information for the given call.
/// </summary>
/// <param name="callInfo">The call object.</param>
/// <param name="callState">The state of the call.</param>
public void CallStateInfo(PhoneCallInfo callInfo, CallState callState)
{
if (InvokeRequired)
{
BeginInvoke((Action<MainForm, PhoneCallInfo, CallState>)((t, c, c1) => t.CallStateInfo(c, c1)), this, callInfo, callState);
return;
}
PhoneCallInfo selectedCall = SelectedCall;
if (selectedCall == null)
return;
if (!selectedCall.Equals(callInfo))
return;
switch (callState)
{
case CallState.InCall:
btnHold.Text = "Hold";
btnHold.Enabled = true;
videoViewerRemote.Start();
break;
case CallState.LocalHeld:
btnHold.Text = "Unhold";
break;
case CallState.RemoteHeld:
btnHold.Text = "Holded";
btnHold.Enabled = false;
break;
case CallState.Completed:
softphoneEngine.StopCamera(callInfo);
videoViewerLocal.Stop();
videoViewerRemote.Stop();
StopRecord();
break;
}
tbPhoneStatus.Text = "Call " + callInfo.Dial + " is " + callState + ".";
}
