SystemState _statePhoneIncoming;
SystemState _StatePhoneActiveCount;
SystemState _phoneCaller;
SystemState _localData;        

public MainForm()
{
    InitializeComponent();

    _statePhoneIncoming = new SystemState(SystemProperty.PhoneIncomingCall, true);
    _statePhoneIncoming.Changed += new ChangeEventHandler(_statePhoneIncoming_Changed);
 
    _StatePhoneActiveCount = new SystemState(SystemProperty.PhoneActiveCallCount, true);
    _StatePhoneActiveCount.Changed += new ChangeEventHandler
				(_StatePhoneActiveCount_Changed);

    _localData = new SystemState(SystemProperty.ConnectionsCount, true);
    _localData.Changed += new ChangeEventHandler(_localData_Changed);

    _phoneCaller = new SystemState(SystemProperty.PhoneIncomingCallerNumber, true);
    _phoneCaller.Changed += new ChangeEventHandler(_phoneCaller_Changed);
}

void _phoneCaller_Changed(object sender, ChangeEventArgs args)
{
    lblLastCallerName.Text = SystemState.PhoneIncomingCallerName;
    lblLastCallerNumber.Text = SystemState.PhoneIncomingCallerNumber;
}

void _localData_Changed(object sender, ChangeEventArgs args)
{
    chkLocalData.Checked = ((int)args.NewValue) > 0;
}

void _StatePhoneActiveCount_Changed(object sender, ChangeEventArgs args)
{
    chkCallActive.Checked = (SystemState.PhoneActiveCallCount > 0) || 
    SystemState.PhoneIncomingCall;
}

void _statePhoneIncoming_Changed(object sender, ChangeEventArgs args)
{
    chkCallActive.Checked = SystemState.PhoneIncomingCall || 
    SystemState.PhoneActiveCallCount > 0;
}

void SendMessage(byte[] message)
{
    for (int i = 0; i < _clientList.Count; ++i)
    {
        //attempt to send each message to the clients individually
        try
        {
            UdpClient client = _clientList[i];
            byte[] encryptedMessage = Encrypt(message);
            client.Send(encryptedMessage, encryptedMessage.Length);
        }
        catch (Exception )
        {
            //If a message could not be sent simply do nothing. 
        }
    }
}

byte[] Encrypt(byte[] message)
{
    MemoryStream    ms = new MemoryStream();
    CryptoStream encStream = new CryptoStream(ms, _transform, CryptoStreamMode.Write);
     encStream.Write(message, 0, message.Length);
     encStream.FlushFinalBlock();
     encStream.Close();
    return ms.ToArray();
} 

public interface IMessageListener: IDisposable
{
    ICryptoTransform CryptoProvider { get; set; }
    void Activate();
    void Deactivate();
    event EventHandler<messagereceivedeventargs> MessageReceived ;
    event EventHandler<listenerstatechangedeventargs> ListenerStateChanged ;
}</listenerstatechangedeventargs></messagereceivedeventargs>

switch (e.MessageType)
{
    case MessageType.Active:
        if (!_senderActive)
            previouslyMuted = device.AudioEndpointVolume.Mute;
        _senderActive = true;
        device.AudioEndpointVolume.Mute = true;
        UpdateStatus("Phone Active");
        break;
    case MessageType.Inactive:
        _senderActive = false;
        device.AudioEndpointVolume.Mute = previouslyMuted;
        UpdateStatus("Phone Inactive");
        break;
    case MessageType.Mute:
        device.AudioEndpointVolume.Mute = previouslyMuted = true;
        UpdateStatus("Mute request received");
        break;
    case MessageType.Unmute:
        previouslyMuted = false;
        device.AudioEndpointVolume.Mute = false;
        UpdateStatus("Unmute request received");
        break;
    case MessageType.CallerID:
        callerIdNotification.Visible = true;
        callerIdNotification.ShowBalloonTip(9000,"Incoming Call",String.Format
	("Call received from {0} ({1})", e.Name, e.Number),ToolTipIcon.Info);
        break;
    default:
        break;
}

void UpdateStatus(String statusMsg)
{
    if (this.InvokeRequired)
    {
        this.Invoke(_updateText, new object[] { statusMsg });
    }
    else
    {
        txtFeedback.Text = statusMsg;
    }
}