Creating a C# Softphone

private void button1_Click(object sender, EventArgs e)
 {

     try
     {
         displayname = textBox1.Text;
         username = textBox2.Text;
         registername = textBox3.Text;
         regpass = textBox9.Text;
         domainhost = textBox4.Text + "." + textBox5.Text + "." + textBox6.Text + "." + textBox7.Text;
         port = Int32.Parse(textBox8.Text);
         switch (comboBox1.SelectedIndex)
         {
             case -1:
             case 0:
                 natTraversal = NatTraversalMethod.None;
                 break;
             case 1:
                 natTraversal = NatTraversalMethod.STUN;
                 break;
             case 2:
                 natTraversal = NatTraversalMethod.TURN;
                 break;
         }
         this.Close();
     }
     catch (Exception ex)
     {
         MessageBox.Show(String.Format("The port number you set is invalid, please set a valid port number.\n {0}", ex.Message), string.Empty, MessageBoxButtons.OK,
         MessageBoxIcon.Error);
     }
}

The NAT traversal is set by a combo box and it has a default value "None" which means there will be no NAT traversal in use. You can also choose STUN and TURN from the list. These traversal types are implemented in the SDK.

If you have set the registration data, the main window opens and you can make a call, if the registration is succesful. If there is any problem with the registration, you can reopen the registration window and correct the registration data.

The Softphone.cs file contains the basic functionality. Writing a softphone needs some basic tools to be defined:

ISoftPhone softPhone;
IPhoneLine phoneLine;
PhoneLineState phoneLineInformation;
IPhoneCall call;
Microphone microphone = new Microphone();
Speaker speaker = new Speaker();
MediaConnector connector = new MediaConnector();
PhoneCallAudioSender mediaSender = new PhoneCallAudioSender();
PhoneCallAudioReceiver mediaReceiver = new PhoneCallAudioReceiver();
bool inComingCall;
RegisterInfo ri;

The most essential method in the class is the InitializeSoftphone that creates a softphone instance and registers it to the PBX:

private void InitializeSoftPhone()
{
    try
    {
        softPhone = SoftPhoneFactory.CreateSoftPhone(SoftPhoneFactory.GetLocalIP(), 5700, 5750, 5700);
        softPhone.IncomingCall += new EventHandler>(softPhone_IncomingCall); 
        //getting registration information
        SIPAccount sa = new SIPAccount(ri.IsRegRequired, ri.displayname, ri.username, ri.registername, ri.regpass, ri.domainhost, ri.port);
        NatConfiguration nc = new NatConfiguration(ri.natTraversal);
        phoneLine = softPhone.CreatePhoneLine(sa, nc);
        phoneLine.PhoneLineStateChanged += new EventHandler>(phoneLine_PhoneLineInformation);
        softPhone.RegisterPhoneLine(phoneLine);
    }
    catch (Exception ex)
    {
        MessageBox.Show(String.Format("You didn't give your local IP adress. Please press the Register button and try it again.\n {0}", ex.Message), string.Empty, MessageBoxButtons.OK,
        MessageBoxIcon.Error);
    }
}

The Exception that occurs here is a VoIPException that is defined in the SDK. The softphones need a port range for outgoing data and a port number for listening purposes. There are some event handlers that also need to be written in the class. For these I basically used the same methods that were written in the sample programs.

The softphone is subscribed to the incoming call event during the initialization. This event is handled in the following method:

private void softPhone_IncomingCall(object sender, VoIPEventArgs e)
{

    InvokeGUIThread(() =>
    {
        label2.Text = "Incoming call";
        label5.Text = String.Format("from {0}", e.Item.DialInfo);
        call = e.Item;
        WireUpCallEvents();
        inComingCall = true;
    });
}

The GUI labels inform you about the basic events like an incoming call. The WireUpCallEvents will subscribe the call for the CallStateChanged and the CallErrorOccured events. The call itself is basically handled in the call_CallStateChanged method:

private void call_CallStateChanged(object sender, VoIPEventArgs e)
{
    InvokeGUIThread(() => { label2.Text = e.Item.ToString(); });
    switch (e.Item)
    {
        case CallState.InCall:
            microphone.Start();
            connector.Connect(microphone, mediaSender);
            speaker.Start();
            connector.Connect(mediaReceiver, speaker);
            mediaSender.AttachToCall(call);
            mediaReceiver.AttachToCall(call);
            break;
        case CallState.Completed:
            microphone.Stop();
            connector.Disconnect(microphone, mediaSender);
            speaker.Stop();
            connector.Disconnect(mediaReceiver, speaker);
            mediaSender.Detach();
            mediaReceiver.Detach();
            WireDownCallEvents();
            call = null;
            InvokeGUIThread(() => { label5.Text = string.Empty; });
            break;
        case CallState.Cancelled:
            WireDownCallEvents();
            call = null;
            break;
    }
}

When a call starts the media connector connects the sender and the receiver to the microphone and the speaker, and then both are attached to the call. The microphone and the speaker, of course, has to be started first. In case of the end of the call the whole process is made backwards. The tools are detached from the call and the devices are disconnected and stopped.

The other methods, like the ones for the keypad button presses, can be used without any modification in any softphone program as I saw. The Ozeki examples also contain DTMF signal handling, but I have not yet used them in my program.

What you will need to run the program

The C# source code that is attached to this article is fully executable without any modifications. You will need a PBX and two registered SIP accounts for the proper work and you will also need to download and install the Ozeki SDK and register it to the project.

When running the project, you will need to set the PBX IP, the listening port and the SIP accounts you have set in the PBX previously. After this you can have your softphones communicate with each other. If you register an IP telephone to the PBX you can also make calls between this softphone and the IP telephone too without any modifications in the code.

Conclusion

This article contained a basic introduction to softphone programming and showed a possible implementation for VoIP communication. The source code I wrote for this article is free to use and to modify by anybody.

Acknowledgment

I need to say thanks to the great developer and support teams of Ozeki Systems Ltd. who kindly answered all my questions about softphone technology and provided the possibility to try their SDK for putting my work into practice.

References

[1] http://voip-sip-sdk.com/p_103-voip-pbx-sdk-compatibility-voip.html

[2] http://www.freepbx.org/

[3] http://voip-sip-sdk.com/p_21-download-ozeki-voip-sip-sdk-voip.html

[4] http://voip-sip-sdk.com/p_100-introduction-to-ozeki-voip-sip-sdk-voip.html