public ClientTelemetryHandler()
        {
            // Aria configuration
            EVTStatus status;

            LogManager.Start(new LogConfiguration());

            _ariaTransmitPolicy = new TransmitPolicy
            {
                ProfileName = "RealTimeForALL",
                Rules       = new List <Rules>
                {
                    new Rules
                    {
                        NetCost = NetCost.Low, PowerState = PowerState.Charging,
                        Timers  = new Timers {
                            Normal = 10, RealTime = 1
                        }
                    }
                }
            };

            LogManager.SetNetCost(_ariaTransmitPolicy.Rules[0].NetCost);
            LogManager.LoadTransmitProfiles(new List <TransmitPolicy> {
                _ariaTransmitPolicy
            });
            LogManager.SetTransmitProfile(_ariaTransmitPolicy.ProfileName);
            LogManager.SetPowerState(PowerState.Charging);

            _ariaTenantId    = TelemetryHandlerConstants.AriaTenantId;
            _ariaEventLogger = LogManager.GetLogger(_ariaTenantId, out status);

            _sessionId        = Guid.NewGuid();
            _msalEventNameKey = TelemetryHandlerConstants.MsalEventNameKey;

            // Set '_logger.WriteToConsole = true' to write out telemetry data to console
            _logger = new Logger();
        }
        public IAsyncResult BeginSetAudioConnected(bool value, TransmitPolicy transmit, AsyncCallback callback)
        {
            AssertSessionNotDeleted();

            AsyncNoResult ar = new AsyncNoResult(callback);

            if (value && transmit == TransmitPolicy.Yes)
            {
                SetTransmitting();
            }
            if (AlreadyDone(value, AudioState))
            {
                ar.CompletedSynchronously = true;
                ar.SetComplete();
                return(ar);
            }
            if (value)
            {
                var request = new vx_req_session_media_connect_t();
                request.session_handle = _sessionHandle;
                VxClient.Instance.BeginIssueRequest(request, result =>
                {
                    try
                    {
                        VxClient.Instance.EndIssueRequest(result);
                        ar.SetComplete();
                    }
                    catch (Exception e)
                    {
                        VivoxDebug.Instance.VxExceptionMessage($"{request.GetType().Name} failed: {e}");
                        ar.SetComplete(e);
                        if (VivoxDebug.Instance.throwInternalExcepetions)
                        {
                            throw;
                        }
                        return;
                    }
                });
                AudioState = ConnectionState.Connecting;
                return(ar);
            }
            else
            {
                _loginSession.ClearTransmittingSession(Channel);

                var request = new vx_req_session_media_disconnect_t();
                request.session_handle = _sessionHandle;
                VxClient.Instance.BeginIssueRequest(request, result =>
                {
                    try
                    {
                        VxClient.Instance.EndIssueRequest(result);
                        ar.SetComplete();
                    }
                    catch (Exception e)
                    {
                        VivoxDebug.Instance.VxExceptionMessage($"{request.GetType().Name} failed: {e}");
                        ar.SetComplete(e);
                        if (VivoxDebug.Instance.throwInternalExcepetions)
                        {
                            throw;
                        }
                        return;
                    }
                });
                AudioState = ConnectionState.Disconnecting;
                return(ar);
            }
        }
        public IAsyncResult BeginConnect(bool connectAudio, bool connectText, TransmitPolicy transmit,
                                         string accessToken, AsyncCallback callback)
        {
            AssertSessionNotDeleted();
            if (string.IsNullOrEmpty(accessToken))
            {
                throw new ArgumentNullException(nameof(accessToken));
            }
            if (!connectAudio && !connectText)
            {
                throw new ArgumentException($"{GetType().Name}: connectAudio and connectText cannot both be false", nameof(connectAudio));
            }
            if (AudioState != ConnectionState.Disconnected || TextState != ConnectionState.Disconnected)
            {
                throw new InvalidOperationException($"{GetType().Name}: Both AudioState and Text State must be disconnected");
            }

            AsyncNoResult ar      = new AsyncNoResult(callback);
            var           request = new vx_req_sessiongroup_add_session_t
            {
                account_handle      = _loginSession.AccountHandle,
                uri                 = Key.ToString(),
                session_handle      = _sessionHandle,
                sessiongroup_handle = GroupId,
                connect_audio       = connectAudio ? 1 : 0,
                connect_text        = connectText ? 1 : 0,
                access_token        = accessToken
            };

            VxClient.Instance.BeginIssueRequest(request, result =>
            {
                try
                {
                    VxClient.Instance.EndIssueRequest(result);
                    ar.SetComplete();
                }
                catch (Exception e)
                {
                    VivoxDebug.Instance.VxExceptionMessage($"{request.GetType().Name} failed: {e}");
                    AudioState = ConnectionState.Disconnected;
                    TextState  = ConnectionState.Disconnected;
                    ar.SetComplete(e);
                    if (VivoxDebug.Instance.throwInternalExcepetions)
                    {
                        throw;
                    }
                    return;
                }
            });

            Debug.WriteLine(transmit);

            if (connectAudio)
            {
                switch (transmit)
                {
                case TransmitPolicy.No:
                {
                    if (_loginSession.TransmittingSession == null)
                    {
                        SetNoSessionTransmitting();
                    }
                }
                break;

                case TransmitPolicy.Yes:
                {
                    SetTransmitting();
                }
                break;

                default:
                    break;
                }
                AudioState = ConnectionState.Connecting;
            }
            if (connectText)
            {
                TextState = ConnectionState.Connecting;
            }

            return(ar);
        }