• The most essential part is the main window that contains all the other elements of the GUI.

  When creating a Windows Form Application, we get a Form object that is our main window. We should resize it for the needed size to be able to contain all the other elements we want to put onto it. We also need to change the Text property to reflect the actual application.
  We can use the mouse to resize the objects or modify the Size property on the Properties panel. Let our main window be 300x295 pixels. We already set the Text property to SoftphoneExample.

• We will need some function buttons for picking up and hanging up the phone

  Let's use two 60x30 pixels Button objects and change the Text and BackColor properties. Now, we have a main window with a LawnGreen "Pick up" and a LightCoral "Hang up" button as Figure 9 shows.

  

• Naturally, we will have to add some essential numbered buttons

  We can use some automatic guidelines for positioning the elements on the form, as it is shown on Figure 10.
  

  

• Having * and # buttons can be useful too

  Telephone functions require the special * and # buttons, so we should add these too.
  Make sure, you always modify the Text property of the buttons. The Name property seems to be the same, but if you modify that, the text on the button will not change.
  Figure 11 shows the final keypad of our softphone. If we want to use other special functionalities, like recording or replaying voice, we will need other function buttons or menus, but for this example, this keypad will do.

  

• We need some space to show the messages and the dialed numbers

  Using a softphone has its advantages, like we can see the status messages or the dialed numbers on the application GUI. For this purpose, the simplest GUI element is a TextBox that can reflect all the messages, we will get. There are more sophisticated methods for this, but this example program only shows the basic possibilities.
  Figure 12 shows the final version of our softphone example application, with all the buttons and the status textbox element.

  

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
//we need to add our using lines here
using Ozeki.Media;
using Ozeki.Media.MediaHandlers;
using Ozeki.Network.Nat;
using Ozeki.VoIP;
using Ozeki.VoIP.Media;
using Ozeki.VoIP.SDK;
using Ozeki.Media.MediaHandlers.Facade;
using Ozeki.Common;

• We have to ask for a softphone object

  As you can see in Code 2, we need to get a softphone object from the SoftPhoneFactory class provided by Ozeki VoIP SIP SDK. We need to set the IP address and the port numbers we want to use for the communication. SoftPhoneFactory can get the local IP address with the GetLocalIP() method, so we use that.

  As for the port numbers, we should add 3 port numbers, the first two defines the range start and end from which the softphone should use the port for sending messages, and the third one defines the port on which the softphone will listen.

• We need to be able to communicate with other networks too

  We also have to set the Network Address Translation (NAT) traversal method. In this case we use the ICE method type.
  The other three string parameters are the server address, the user name and the password. If you have these parameters specified by your provider, you can set it here.
  Note that you have to use your own data to make the application work properly.

• How do we notice an incoming call?

  We have to register our softphone to the incoming call events, this is the 07 line in the code. This ensures that the softphone will be aware of the incoming calls.

• Now we can specify the information for the PBX

  For communicating with a softphone, we will need a phone line, defined in the 08 line in Code 2. The phoneLine object needs the SIP account you got from your SIP provider. The parameters of the SIPAccount constructor can be set with the usernames and passwords your provider gave to you.

  The first bool parameter shows if there is a need for the registration of the softphone before initiating the call.

  Then you need to set some string parameters listed below.
  Note that the example code shows sample data which will not work on your computers properly. Use your own data to fill these parameters.
  The four string parameters are for

  1. the name you want to display
  2. the username you got from your provider
  3. the register name
  4. the register password

  Next you have to give the domain server host IP and the domain server port you want to use.
  Note that the IP and port numbers are only for demonstration in this code, please use your own domain server host data to make your application work properly.

• The last step is to register the state change

  We have to sign up for the EventHandler that informs us when the line state changed. This is essential, as we want to know, for example, if the call ended. The last line in Code 2 gives us this possibility.

private void InitializeSoftPhone()
        try
        {
             softPhone = SoftPhoneFactory.CreateSoftPhone(SoftPhoneFactory.GetLocalIP(), 5700, 5750, 5700);
                softPhone.IncomingCall += new EventHandler<VoIPEventArgs<IPhoneCall>>(softPhone_IncomingCall);
                phoneLine = softPhone.CreatePhoneLine(new SIPAccount(true, "oz876", "oz876", "oz876", "oz876", "192.168.112.100", 5060), new NatConfiguration(NatTraversalMethod.None));
                phoneLine.PhoneLineStateChanged += new EventHandler<VoIPEventArgs<PhoneLineState>>(phoneLine_PhoneLineInformation);

softPhone.RegisterPhoneLine(phoneLine);

catch (Exception ex)
            {
                MessageBox.Show(String.Format("You didn't give your local IP adress, so the program won't run properly.\n {0}", ex.Message), string.Empty, MessageBoxButtons.OK,
                MessageBoxIcon.Error);

                var sb = new StringBuilder();
                sb.AppendLine("Some error happened.");
                sb.AppendLine();
                sb.AppendLine("Exception:");
                sb.AppendLine(ex.Message);
                sb.AppendLine();
                if (ex.InnerException != null)
                {
                    sb.AppendLine("Inner Exception:");
                    sb.AppendLine(ex.InnerException.Message);
                    sb.AppendLine();
                }
                sb.AppendLine("StackTrace:");
                sb.AppendLine(ex.StackTrace);

                MessageBox.Show(sb.ToString());
                }

• We need to know if the registration to the line has been succeeded We only have to start the registration process as a daemon thread in our application. This thread constantly checks if the registration to the PBX is successful. The registration status will be shown on the textBox GUI element. We always need a succeeded registration to be able to start a call.

  Code 5 shows the simple method for handling phone line information. It basically contains a single conditional instruction that checks the registration status in a background thread. When there is a change in the status, the Text property of textbox object will be changed according to the registration status.

  private void phoneLine_PhoneLineInformation(object sender, VoIPEventArgs<PhoneLineState> e)
          {
              phoneLineInformation = e.Item;
              InvokeGUIThread(() =>
              {
                  label2.Text = ((IPhoneLine)sender).SIPAccount.RegisterName;
                  if (e.Item == PhoneLineState.RegistrationSucceeded)
                  {
                     label3.Text = "Registration succeeded";
                     label1.Text = "Online";
  
                  }
                  else
                      label1.Text = e.Item.ToString();
              });
          }
  

  After a successful registration, we will be able to make and receive calls. Now we need to write some methods for handling the incoming calls. We will cover the outgoing calls in another section, as they are connected to the keypad buttons.

• We have to be able to notice that there is an incoming call. For this purpose we use a simple handler method shown in Code 6. An incoming message is an event that is needed to notice with our softphone. This simple method that also runs as a background thread uses the textbox on the GUI to show that there is an incoming call. It also shows the source of the call.
  This method does not answer the call, it is a matter of a keypad activity, and it only makes a notification to the user about the call.

  The inComingCall bool variable becomes true in case of an incoming call in this method. It is essential as the application will check this bool when the Pick Up button is pressed.

   private void softPhone_IncomingCall(object sender, VoIPEventArgs<IPhoneCall> e)
          {
              InvokeGUIThread(() =>
              {
                  label1.Text = "Incoming call ";
                  textBox1.Text += String.Format("from {0}", e.Item.DialInfo);
                  call = e.Item;
                  WireUpCallEvents();
                  inComingCall = true;
              });
          }
  

  The call itself has states that must be watched so the softphone can react to them properly. We can use another background thread for this purpose.

• It is time to handle the hardware

  When using a softphone, there are some specific hardware devices that are in use. We want to use these devices properly, so we need to know when these should be started or stopped. The next code sections show how easy it is to handle these devices.

  Figure 13 shows how you need to connect the audio and video tools when you want to make your softphone or videophone work.

  

  Code 7 contains the main concept of handling the call state change. The method starts a new background thread as all the listeners before. This thread will watch the CallState object and react to its changes.

  In Code 7 we see that in case of an incoming call, we should start the microphone and connect it to the mediaSender object, as it will be the device through which we send the voice messages.

  In case of an incoming call, we also need to start the receiver that is the speaker.

  After starting these devices, we just attach them to the call and they are ready to use.

  private void call_CallStateChanged(object sender, VoIPEventArgs<CallState> e)
          {
              InvokeGUIThread(() => { textBox1.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;
  

  After finishing a call we need to stop the devices and detach them from the call object. We use the same method as for the incoming calls and write another case block to the switch instruction.

  The finished call event has to change the textbox Text too, as the softphone user needs to be noticed about the end of the call.

  case CallState.Completed:
      microphone.Stop();
      connector.Disconnect(microphone, mediaSender);
  
      speaker.Stop();
      connector.Disconnect(mediaReceiver, speaker);
  
      mediaSender.Detach();
      mediaReceiver.Detach();
  
      WireDownCallEvents();
      call = null;
  
      InvokeGUIThread(() => { textBox1.Text = string.Empty; });
      break;
  

  We have to handle the case, when the call is not answered but cancelled. In this case we need to set the call object null to indicate that there is no communication.
  Note that the call was set to null in case of the finished calls too.

          case CallState.Cancelled:
              WireDownCallEvents();
              call = null;
              break;
      }
  }
  

• We can receive some special signals while using a softphone

  During the calls, we can get some special signals through the line. These are called Dual-tone multi-frequency signals (DTMF), and they occur when some of the users press the numbered buttons while speaking. This can be familiar from analog telephones where we can hear the DTMF as beep sounds.

  We can actually play the DTMF signals with the speaker, but in most cases we don't really want to hear some R2D2 language while speaking to somebody. In this case we can simply mask the signals or only show them on the textbox. The method in Code 10 does this last version.
  We don't have to do much with DTMF signals as the Ozeki VoIP SIP SKD has the support for identifying them.

  private void call_DtmfReceived(object sender, VoIPEventArgs<DtmfInfo> e)
  {
      DtmfInfo dtmfInfo = e.Item;
  
      InvokeGUIThread(() =>
      {
          label1.Text = String.Format("DTMF signal received: {0} ", dtmfInfo.Signal.Signal);
      });
  }
  

• We always have to prepare for unexpected events

  Error handling is a very important part of every application, so do not forget to write an error handler method (Code 11).

  private void call_CallErrorOccured(object sender, VoIPEventArgs<CallError> e)
  {
      InvokeGUIThread(() =>
      {
          label1.Text = e.Item.ToString();
      });
  }
  
  

private void buttonPickUp_Click(object sender, EventArgs e)
{
    if (inComingCall)
    {
        inComingCall = false;
        call.Accept();
        return;
    }

    if (call != null)
        return;

    if (string.IsNullOrEmpty(textBox1.Text))
        return;

    if (phoneLineInformation != PhoneLineState.RegistrationSucceeded && phoneLineInformation != PhoneLineState.NoRegNeeded)
    {
        MessageBox.Show("Phone line state is not valid!");
        return;
    }

    call = softPhone.CreateCallObject(phoneLine, textBox1.Text);
    WireUpCallEvents();
    call.Start();
}

private void buttonHangUp_Click(object sender, EventArgs e)
{
   if (call != null)
    {
        if (inComingCall && call.CallState==CallState.Ringing)
            call.Reject();
        else
            call.HangUp();
        inComingCall = false;
        call = null;

    }
    textBox1.Text = string.Empty;
}

private void buttonKeyPadButton_Click(object sender, EventArgs e)
{
    var btn = sender as Button;
    if (btn != null)
    {
        if (btn.Text == "0/+")
        {
            textBox1.Text += "0";
        }
        else
            textBox1.Text += btn.Text.Trim();
    }
}

private void buttonKeyPadButton_MouseDown(object sender, MouseEventArgs e)
{
    if (call != null && call.CallState == CallState.InCall)
    {
        var btn = sender as Button;
        if (btn != null)
        {
            int id;

            if (btn.Tag != null && int.TryParse(btn.Tag.ToString(), out id))
            {
                call.StartDTMFSignal((DtmfNamedEvents)id);
            }
        }
    }
}

private void buttonKeyPad_MouseUp(object sender, MouseEventArgs e)
{
    if (call != null && call.CallState == CallState.InCall)
    {
        var btn = sender as Button;
        if (btn != null)
        {
            int id;

            if (btn.Tag != null && int.TryParse(btn.Tag.ToString(), out id))
            {
                call.StopDTMFSignal((DtmfNamedEvents)id);
            }
        }
    }
}

private void WireUpCallEvents()
{
    call.CallStateChanged += (call_CallStateChanged);
    call.DtmfReceived += (call_DtmfReceived);
    call.CallErrorOccured += (call_CallErrorOccured);
}


private void WireDownCallEvents()
{
    if (call != null)
    {
        call.CallStateChanged -= (call_CallStateChanged);
        call.DtmfReceived -= (call_DtmfReceived);
        call.CallErrorOccured -= (call_CallErrorOccured);
    }

}

private void InvokeGUIThread(Action action)
        {
            Invoke(action);
        }

• How to build a softphone
• Quick start guide
• Download Ozeki VoIP SIP SDK form the Ozeki VoIP SIP SDK download page
• For further examples using Ozeki VoIP SIP SDK, visit the SIP voice applications