RTP/src/model/SIPmodel.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package model;

import gov.nist.javax.sip.DialogTimeoutEvent;
import gov.nist.javax.sip.SipListenerExt;
import gui.Hauptfenster;
import java.net.InetAddress;
import java.text.ParseException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.sdp.SdpException;
import javax.sdp.SdpFactory;
import javax.sdp.SessionDescription;
import javax.sip.DialogTerminatedEvent;
import javax.sip.IOExceptionEvent;
import javax.sip.InvalidArgumentException;
import javax.sip.ListeningPoint;
import javax.sip.RequestEvent;
import javax.sip.ResponseEvent;
import javax.sip.SipException;
import javax.sip.SipFactory;
import javax.sip.SipProvider;
import javax.sip.SipStack;
import javax.sip.TimeoutEvent;
import javax.sip.TransactionTerminatedEvent;
import javax.sip.address.*;
import javax.sip.header.*;
import javax.sip.message.*;
import logger.OhmLogger;

/**
 *
 * @author Jan komplettes Model für SIPmodel evtl. Vererbung und für jeden SIP
 * Response/Request eigene Klasse oder Interface da es langsam unübersichtlich
 * wird :( ACK schicken muss noch ergänzt werden BYE muss noch ergänzt werden.
 */
public class SIPmodel implements SipListenerExt
{
  Hauptfenster view; //später entfernen wegen Zugriff
  public static final Logger lg = OhmLogger.getLogger();
  public SipFactory sipFactory;          // Used to access the SIP API.
  public SipStack sipStack;              // The SIP stack.
  public SipProvider sipProvider;        // Used to send SIP messages.
  public MessageFactory messageFactory;  // Used to create SIP message factory.
  public HeaderFactory headerFactory;    // Used to create SIP headers.
  public AddressFactory addressFactory;  // Used to create SIP URIs.
  public ListeningPoint listeningPoint;  // SIP listening IP address/port.
  public Properties properties;          // Other properties.

  private String[][] codecs; //unterstütze Codecs[RTP-Parameter][CodecBezeichnung]

  public int myPort = 5060;
  public String myName = "129";
  public String protocolTyp = "UDP";
  public String myIPAddress;
  public String proxyAddress;
  public CallIdHeader callID;

  Boolean invite; //Bool für SDP falls ich anrufe

  //Hilfsvariablen wenn ich angerufen werde. evtl. noch optimieren
  RequestEvent evtWerdeAngerufen;
  Boolean werdeAngerufen;
  private int countWerdeAngerufen;

  public long cSequenz = 1;
  public String proxyTag;
  public int myTag = (new Random()).nextInt();
  public int branch = hashCode();
  public Address contactAddress;
  public ContactHeader contactHeader;

  public SIPmodel(Hauptfenster view) //Konstruktor für eigene Daten     
  {
    this.view = view;
    invite = true;
    proxyAddress = "";

    countWerdeAngerufen = 0;
    evtWerdeAngerufen = null;
    werdeAngerufen = false;
    codecs = new String[4][2]; // Alle unterstützen Codecs eintragen
    codecs[0][0] = "0";
    codecs[0][1] = "PCMU/8000";
    codecs[1][0] = "4";
    codecs[1][1] = "G723/8000";
    codecs[2][0] = "8";
    codecs[2][1] = "PCMA/8000";
    codecs[3][0] = "18";
    codecs[3][1] = "G729/8000";

    try
    {
      //wird an sich erstmal nicht gebraucht aber später sinnvoll um eigene Daten zu initialisieren
      String abc = InetAddress.getLocalHost().getHostAddress();
      this.myIPAddress = InetAddress.getLocalHost().getHostAddress();
      this.sipFactory = SipFactory.getInstance();
      this.sipFactory.setPathName("gov.nist");
      this.properties = new Properties();
      this.properties.setProperty("javax.sip.STACK_NAME", "stack");
      this.sipStack = this.sipFactory.createSipStack(this.properties);
      this.messageFactory = this.sipFactory.createMessageFactory();
      this.headerFactory = this.sipFactory.createHeaderFactory();
      this.addressFactory = this.sipFactory.createAddressFactory();
      this.listeningPoint = this.sipStack.createListeningPoint(this.myIPAddress, this.myPort, this.protocolTyp);
      this.sipProvider = this.sipStack.createSipProvider(this.listeningPoint);
      this.sipProvider.addSipListener(this);
      //this.contactAddress = this.addressFactory.createAddress("sip:129@" + this.myIPAddress + ":" + this.myPort); //+ ":" + this.myPort
      this.contactAddress = this.addressFactory.createAddress("sip:" + myName + "@" + this.myIPAddress + ":" + this.myPort);
      this.contactHeader = this.headerFactory.createContactHeader(contactAddress);
    }
    catch (Exception e)
    {
      System.out.println("Fehler bei Initialisierung eigener Addresse");
      System.exit(-1);
    }
  }

  public int hashCode()
  {
    int temp = myTag * (new Random(100)).nextInt();
    return temp;
  }

  public void sendRegister(String serverIP, int serverPort) throws ParseException, InvalidArgumentException, SipException
  {
    lg.info("Vorbereiten des Registrierungs Headers");
    proxyAddress = serverIP + ":" + serverPort;
    Address addressto = this.addressFactory.createAddress("sip:" + proxyAddress); //evtl. mit Port: sip:192.168.100.11:5060
    ToHeader to = this.headerFactory.createToHeader(addressto, null); // Integer.toString(myTag)  address + myTag
    URI requestURI = addressto.getURI();
    CallIdHeader callId = this.sipProvider.getNewCallId();
    FromHeader from = this.headerFactory.createFromHeader(addressto, String.valueOf(this.myTag)); //this.contactAddress
    ArrayList via = new ArrayList(); //Via needs a List as input
    ViaHeader viaheader = this.headerFactory.createViaHeader(this.myIPAddress, this.myPort, "UDP", String.valueOf(branch));
    via.add(viaheader);
    CSeqHeader cSeq = this.headerFactory.createCSeqHeader(1L, "REGISTER");
    MaxForwardsHeader maxForwards = this.headerFactory.createMaxForwardsHeader(70);
    AllowHeader allow = this.headerFactory.createAllowHeader("NOTIFY,INVITE,ACK,CANCEL,BYE,REFER,INFO,OPTIONS,MESSAGE");
    ExpiresHeader expire = this.headerFactory.createExpiresHeader(3600); //int value 
    Request request = this.messageFactory.createRequest(requestURI, "REGISTER", callId, cSeq, from, to, via, maxForwards);
    request.addHeader(contactHeader);
    request.addHeader(allow);
    request.addHeader(expire);
    this.sipProvider.sendRequest(request);
    lg.info("Erfolgreiches Senden der Registrierung");
  }

  public void sendInvitation(String sipaddresse, String proxyaddresse,
                             int serverPort) throws ParseException, InvalidArgumentException, SipException, SdpException
  {
    invite = true;
    Address addressto = this.addressFactory.createAddress("sip:" + sipaddresse + "@" + proxyaddresse);
    ToHeader to = this.headerFactory.createToHeader(addressto, null); // Integer.toString(myTag)  address + myTag
    URI requestURI = addressto.getURI();
    callID = this.sipProvider.getNewCallId();
    FromHeader from = this.headerFactory.createFromHeader(addressto, String.valueOf(this.myTag)); //this.contactAddress
    ArrayList via = new ArrayList(); //Via needs a List as input
    ViaHeader viaheader = this.headerFactory.createViaHeader(this.myIPAddress, this.myPort, "UDP", String.valueOf(branch));
    via.add(viaheader);

    CSeqHeader cSeq = this.headerFactory.createCSeqHeader(cSequenz, "INVITE");

    MaxForwardsHeader maxForwards = this.headerFactory.createMaxForwardsHeader(70);
    AllowHeader allow = this.headerFactory.createAllowHeader("NOTIFY,INVITE,ACK,CANCEL,BYE,REFER,INFO,OPTIONS,MESSAGE");
    ExpiresHeader expire = this.headerFactory.createExpiresHeader(3600); //int value 
    Request request = this.messageFactory.createRequest(requestURI, "INVITE", callID, cSeq, from, to, via, maxForwards);
    request.addHeader(contactHeader);
    request.addHeader(allow);
    request.addHeader(expire);
    ContentTypeHeader content = headerFactory.createContentTypeHeader("application", "sdp");
    request.addHeader(content);
    request.setContent(createSDPHeader(null), content);
    this.sipProvider.sendRequest(request);

    lg.info("Erfolgreiches Senden der Invitation");
  }

  @Override
  public void processRequest(RequestEvent requestEvent)
  {
    lg.info("Bekomme Anfrage");
    if ((Request.OPTIONS).equals(requestEvent.getRequest().getMethod())) //Options Anfrage von Server nach erfolgreicher Registrierung
    {
      lg.info("Option Request von Server, erstellen 200 OK zu Server");
      try
      {
        this.sipProvider.sendResponse(create200Ok(requestEvent));
        view.getTxtArea().append("Server Option Request erfolgreich beantwortet\n");
        lg.info("Erfolgreiches senden des Headers");
      }
      catch (ParseException | SipException ex)
      {
        lg.getLogger(SIPmodel.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    //Aktive Kommunikation
    else if ((Request.INVITE).equals(requestEvent.getRequest().getMethod())) // Invite von anderem Benutzer
    {
      try
      {
        this.sipProvider.sendResponse(create180Ringing(requestEvent));
        view.getTxtArea().append("Ringing geschickt\n");
      }
      catch (Exception ex)//Exceptions evtl. genauer definieren
      {
        lg.getLogger(SIPmodel.class.getName()).log(Level.SEVERE, null, ex);
      }
      countWerdeAngerufen++; //bessere Lösung muss her!!, was schickt andere User oder Proxy bei nicht erreichen
      FromHeader abc = (FromHeader) requestEvent.getRequest().getHeader("From");

      evtWerdeAngerufen = requestEvent;
      System.out.println(countWerdeAngerufen);
      if (countWerdeAngerufen < 7)
      {
        werdeAngerufen = true;
        lg.info("Hab Invitation bekommen");
        view.getTxtArea().append("Werde von " + abc.getAddress() + " angerufen\n");
      }
      else
      {
        werdeAngerufen = false;
        lg.info("Leider waren Sie nicht erreichbar");
        view.getTxtArea().append("Sie waren nicht erreichbar\n");
        countWerdeAngerufen = 0;
      }

    }
    else if ((Request.ACK).equals(requestEvent.getRequest().getMethod()))
    {

    }
    else if ((Request.CANCEL).equals(requestEvent.getRequest().getMethod()))
    {
      view.getTxtArea().append("Anruf wurde gecancelt");
      try
      {
        //Cancel Request -> Response 200 Ok + Response 487 Request Terminated
        //200 Ok
        werdeAngerufen = false;
        evtWerdeAngerufen = null; // sicher ist sicher 
        this.sipProvider.sendResponse(create200Ok(requestEvent));
        view.getTxtArea().append("Anrufender canceld Anfrage\n");
        lg.info("Erfolgreiches senden des 200 OkHeaders auf CancelAnfrage");
        //487 Request Terminated

      }
      catch (ParseException | SipException ex)
      {
        Logger.getLogger(SIPmodel.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    else if ((Request.BYE).equals(requestEvent.getRequest().getMethod()))
    {
      try
      {
        this.sipProvider.sendResponse(create200Ok(requestEvent));
      }
      catch (Exception ex)
      {

      }
    }
  }

  @Override
  public void processResponse(ResponseEvent responseEvent)
  {
    System.out.println("---Response---");
    //System.out.println(responseEvent.getResponse());

    if (responseEvent.getResponse().getStatusCode() == Response.UNAUTHORIZED)
    {
      try
      {
        Address addresstob = this.addressFactory.createAddress("sip:" + myName + "@" + proxyAddress);
        ToHeader temp = (ToHeader) responseEvent.getResponse().getHeader("To");

        ToHeader to = this.headerFactory.createToHeader(addresstob, temp.getTag()); // Integer.toString(myTag)  address + myTag
        URI requestURI = addresstob.getURI();
        CallIdHeader callId = (CallIdHeader) responseEvent.getResponse().getHeader("Call-ID");
        FromHeader from = this.headerFactory.createFromHeader(addresstob, String.valueOf(this.myTag)); //this.contactAddress 
        WWWAuthenticateHeader wwwauth = (WWWAuthenticateHeader) responseEvent.getResponse().getHeader("WWW-Authenticate");

        //wird bei AuthorizationHeader wirklich alles benötigt? war glaub nur mal Test -> testen!!
        AuthorizationHeader auth = this.headerFactory.createAuthorizationHeader("Digest");//was kommt in den string
        auth.setRealm(wwwauth.getRealm());
        auth.setNonce(wwwauth.getNonce());
        //Address addresstest = this.addressFactory.createAddress("sip:" + myName + "@192.168.100.11"); //vielleicht passwort setzen "sip:"+myName+":\"\"@192.168.100.11"
        Address addresstest = this.addressFactory.createAddress("sip:" + myName + "@" + proxyAddress);
        auth.setURI(addresstest.getURI());
        auth.setUsername(myName);

        ArrayList via = new ArrayList(); //Via needs a List as input
        ViaHeader viaheader = this.headerFactory.createViaHeader(this.myIPAddress, this.myPort, "UDP", String.valueOf(branch + 2));// String.valueOf(hashCode())string branch
        via.add(viaheader);

        CSeqHeader cSeq = this.headerFactory.createCSeqHeader(2L, "REGISTER");
        MaxForwardsHeader maxForwards = this.headerFactory.createMaxForwardsHeader(70);
        AllowHeader allow = this.headerFactory.createAllowHeader("NOTIFY,INVITE,ACK,CANCEL,BYE,REFER,INFO,OPTIONS,MESSAGE");
        ExpiresHeader expire = this.headerFactory.createExpiresHeader(3600); //int value

        //Zusätzliche Register Header nach Unauthorzied
        //Create Request Header
        Request request = this.messageFactory.createRequest(requestURI, "REGISTER", callId, cSeq, from, to, via, maxForwards);
        request.addHeader(contactHeader);
        request.addHeader(allow);
        request.addHeader(expire);
        request.addHeader(auth);
        this.sipProvider.sendRequest(request);
        view.getTxtArea().append("Erfolgreich registriert\n");
      }
      catch (ParseException | SipException | InvalidArgumentException ex)
      {
        lg.getLogger(SIPmodel.class.getName()).log(Level.SEVERE, null, ex);
      }

    }
    else if (responseEvent.getResponse().getStatusCode() == Response.OK)
    {
      lg.info("Erfolgreichen Response (200 OK) bekommen");
    }
    else if (responseEvent.getResponse().getStatusCode() == Response.RINGING)
    {
      ToHeader temp = (ToHeader) responseEvent.getResponse().getHeader("To");
      proxyTag = temp.getTag();

    }

  }

  public Response create200Ok(RequestEvent requestEvent) throws ParseException
  {
    Response response = this.messageFactory.createResponse(200, requestEvent.getRequest());
    response.addHeader((ViaHeader) requestEvent.getRequest().getHeader("Via"));
    response.addHeader((FromHeader) requestEvent.getRequest().getHeader("From"));
    response.addHeader((ToHeader) requestEvent.getRequest().getHeader("To"));
    response.addHeader((CallIdHeader) requestEvent.getRequest().getHeader("Call-ID"));
    response.addHeader((CSeqHeader) requestEvent.getRequest().getHeader("Cseq"));
    response.addHeader(contactHeader);
    AllowHeader allow = this.headerFactory.createAllowHeader("NOTIFY,INVITE,ACK,CANCEL,BYE,REFER,INFO,OPTIONS,MESSAGE");
    AllowEventsHeader allowevents = this.headerFactory.createAllowEventsHeader("talk,hold,refer,call-info");
    response.addHeader((CallIdHeader) requestEvent.getRequest().getHeader("Call-ID"));
    response.addHeader(allow);
    response.addHeader(allowevents);
    return response;
  }

  public Response create180Ringing(RequestEvent requestEvent) throws ParseException, SipException
  {
    
    Response responsering = this.messageFactory.createResponse(180, requestEvent.getRequest());
    responsering.addHeader((ViaHeader) requestEvent.getRequest().getHeader("Via"));
    responsering.addHeader((FromHeader) requestEvent.getRequest().getHeader("From"));
    AllowHeader allow = this.headerFactory.createAllowHeader("NOTIFY,INVITE,ACK,CANCEL,BYE,REFER,INFO,OPTIONS,MESSAGE");
    //Bei Ringing muss persönlicher Tag ergänzt werden
    ToHeader temptoring = (ToHeader) requestEvent.getRequest().getHeader("To");
    proxyTag = temptoring.getTag();
    temptoring.setTag(String.valueOf(this.myTag));
    responsering.addHeader(temptoring);
    cSequenz = ((CSeqHeader) requestEvent.getRequest().getHeader("Cseq")).getSeqNumber();
    responsering.addHeader((CSeqHeader) requestEvent.getRequest().getHeader("Cseq"));
    responsering.addHeader(contactHeader);
    responsering.addHeader(allow);
    AllowEventsHeader allowevent = this.headerFactory.createAllowEventsHeader("talk,hold,refer,call-info");// für was gebraucht
    responsering.addHeader(allowevent);
    return responsering;
  }

  public SIPmodel()
  {
  }

  public SessionDescription createSDPHeader(ArrayList<String> reqSDP) throws SdpException
  {
    SdpFactory sdpFactory = SdpFactory.getInstance();
    SessionDescription sessionDescription = sdpFactory.createSessionDescription();
    sessionDescription.setOrigin(sdpFactory.createOrigin(myName, 8000, 8000, "IN", "IP4", myIPAddress));
    sessionDescription.setSessionName(sdpFactory.createSessionName("SIP Call"));
    sessionDescription.setConnection(sdpFactory.createConnection("IN", "IP4", myIPAddress));

    //Media Body
    Vector mediavec = new Vector();
    String cods[] = new String[codecs.length];
    System.out.println("System out: " + codecs.length);

    for (int i = 0; i < cods.length; i++)//Übertragung der RTP-Values in neues Array
    {
      cods[i] = codecs[i][0];
    }

    mediavec.add(sdpFactory.createMediaDescription("audio", 6022, 1, "RTP/AVP", cods)); //(Übertragungstyp, Port, anzahl der Ports, Verbindungstyp,..)
    mediavec.add(sdpFactory.createAttribute("sendrecv", null));
    if (invite = true)
    {
      for (int i = 0; i == codecs[0].length; i++)
      {
        System.out.println("Codecs: " + codecs[i][0] + " " + codecs[i][1]);
        mediavec.add(sdpFactory.createAttribute("rtpmap", codecs[i][0] + " " + codecs[i][1]));
      }
    }
    else//Vergleich von eigenen Codecs mit Codecs der anruft -> Rückgabe entsprechend wählen
    {
      boolean temp = true; //evtl noch was besseres da so erster Codec nicht bester verwendet wird
      for (int i = 0; i == codecs[0].length; i++)
      {
        if (codecs[i][1].equals(reqSDP) && temp == true)
        {
          mediavec.add(sdpFactory.createAttribute("rtpmap", "8 G711a/8000"));
          temp = false;
        }
      }
    }
    sessionDescription.setAttributes(mediavec);
    return sessionDescription;
  }

  public void annehmen() //Fehlende Bedingung 
  {
    RequestEvent requestEvent;
    if ((requestEvent = evtWerdeAngerufen) != null && werdeAngerufen == true)
    {
      countWerdeAngerufen = 0;

      try
      {
        callID = (CallIdHeader) requestEvent.getRequest().getHeader("Call-ID");
        //Trying Message to Server (Response Trying)
        Response responsetry = this.messageFactory.createResponse(100, requestEvent.getRequest());
        responsetry.addHeader((ViaHeader) requestEvent.getRequest().getHeader("Via"));
        responsetry.addHeader((FromHeader) requestEvent.getRequest().getHeader("From"));
        responsetry.addHeader((ToHeader) requestEvent.getRequest().getHeader("To"));
        responsetry.addHeader((CallIdHeader) requestEvent.getRequest().getHeader("Call-ID"));
        responsetry.addHeader((CSeqHeader) requestEvent.getRequest().getHeader("Cseq"));

        CSeqHeader tempcs = (CSeqHeader) requestEvent.getRequest().getHeader("Cseq");
        tempcs.getSeqNumber();
        SupportedHeader supp = this.headerFactory.createSupportedHeader("replace,path,timer"); //nachschauen
        AllowHeader allow = this.headerFactory.createAllowHeader("NOTIFY,INVITE,ACK,CANCEL,BYE,REFER,INFO,OPTIONS,MESSAGE");

        responsetry.addHeader(supp);
        responsetry.addHeader(allow);
        this.sipProvider.sendResponse(responsetry);
        view.getTxtArea().append("Trying geschickt\n");
        lg.info("Trying ist raus");

        //Ringing Message to Server (Responste Ringing)
        Response responsering = this.messageFactory.createResponse(180, requestEvent.getRequest());
        responsering.addHeader((ViaHeader) requestEvent.getRequest().getHeader("Via"));
        responsering.addHeader((FromHeader) requestEvent.getRequest().getHeader("From"));

        ToHeader temptoring = (ToHeader) requestEvent.getRequest().getHeader("To");
        String tempTag = String.valueOf(this.myTag + Math.random());
        temptoring.setTag(tempTag); //evtl. besseren Tag
        responsering.addHeader(temptoring);

        responsering.addHeader((CSeqHeader) requestEvent.getRequest().getHeader("Cseq"));
        responsering.addHeader(contactHeader);
        responsering.addHeader(supp);
        responsering.addHeader(allow);

        AllowEventsHeader allowevent = this.headerFactory.createAllowEventsHeader("talk,hold");// für was gebraucht
        responsering.addHeader(allowevent);
        this.sipProvider.sendResponse(responsering);
        view.getTxtArea().append("Ringing geschickt\n");

        //Jetzt kommt 200 Ok SIP Header + SDP (SIP/SDP)
        //Sdp Header erstellen nächster Schritt
        invite = false;
        Response okandSDP = this.messageFactory.createResponse(Response.OK, requestEvent.getRequest());
        //okandSDP.addHeader((ViaHeader) requestEvent.getRequest().getHeader("Via"));
        okandSDP.addHeader((FromHeader) requestEvent.getRequest().getHeader("From"));

        okandSDP.addHeader(temptoring); //evtl noch Ergänzungen

        okandSDP.addHeader((CSeqHeader) requestEvent.getRequest().getHeader("Cseq"));
        okandSDP.addHeader(contactHeader);
        okandSDP.addHeader(supp);
        okandSDP.addHeader(allow);
        okandSDP.addHeader(allowevent);
        ContentTypeHeader content = headerFactory.createContentTypeHeader("application", "sdp");
        okandSDP.addHeader(content);

        String[] reqbody = (requestEvent.getRequest()).toString().split("\\s|" + System.getProperty("line.seperator"));//Req. Body in Zeilen aufteilen
        ArrayList<String> reqSDP = new ArrayList<>();
        for (String req : reqbody)//jeden String durchgehen und nach Codecs suchen die unterstützt werden
        {
          if (req.startsWith("a=rtpmap"))
          {
            reqSDP.add(req.replace("a=rtpmap:", ""));
            System.out.println(reqSDP);
          }
        }
        okandSDP.setContent(createSDPHeader(reqSDP), content);
        this.sipProvider.sendResponse(okandSDP);

        view.getTxtArea().append("Telefonat beginnt\n");
        evtWerdeAngerufen = null;
      }
      catch (ParseException | SipException | SdpException ex)
      {
        Logger.getLogger(SIPmodel.class.getName()).log(Level.SEVERE, null, ex);

      }
    }
    else
    {
      view.getTxtArea().append("Zur Zeit gibt es keinen Anruf\n");
    }

  }

  public void byecall(String calluser) throws ParseException, InvalidArgumentException, SipException
  {
    invite = false;
    Address addressLine = this.addressFactory.createAddress("sip:" + calluser + "@" + proxyAddress);
    URI requestURI = addressLine.getURI();

    Address addressfrom = this.addressFactory.createAddress("sip:" + myName + "@" + myIPAddress);
    FromHeader from = this.headerFactory.createFromHeader(addressfrom, String.valueOf(this.myTag));

    Address addressTo = this.addressFactory.createAddress("sip:" + myName + "@" + proxyAddress);
    ToHeader to = this.headerFactory.createToHeader(addressTo, proxyTag); // Ergänzung TAG!!

    ArrayList via = new ArrayList(); //Via needs a List as input
    ViaHeader viaheader = this.headerFactory.createViaHeader(this.myIPAddress, this.myPort, "UDP", String.valueOf(branch));
    via.add(viaheader);

    cSequenz++;
    CSeqHeader cSeq = this.headerFactory.createCSeqHeader(cSequenz, "BYE");
    MaxForwardsHeader maxForwards = this.headerFactory.createMaxForwardsHeader(70);
    AllowHeader allow = this.headerFactory.createAllowHeader("NOTIFY,INVITE,ACK,CANCEL,BYE,REFER,INFO,OPTIONS,MESSAGE");
    ExpiresHeader expire = this.headerFactory.createExpiresHeader(3600); //int value 
    Request request = this.messageFactory.createRequest(requestURI, "BYE", callID, cSeq, from, to, via, maxForwards);
    request.addHeader(contactHeader);
    request.addHeader(allow);
    request.addHeader(expire);
    this.sipProvider.sendRequest(request);
    invite = false;

    lg.info("Erfolgreiches Senden des BYE Headers");
  }

  //Get Methoden falls man mal die Parameter braucht
  public String getmyName()
  {
    return myName;
  }

  public Integer getMyPort()
  {
    return myPort;
  }

  public String getMyIPAdress()
  {
    return myIPAddress;
  }

  // Herausfinden bei welchen Events die unteren Funktionen aufgerufen werden -> evtl brauchbar
  @Override
  public void processTimeout(TimeoutEvent timeoutEvent)
  {
    //view.getTxtArea().append("processTimeout\n"); 
  }

  @Override
  public void processIOException(IOExceptionEvent exceptionEvent)
  {
    //view.getTxtArea().append("processIOException\n"); 
  }

  @Override
  public void processTransactionTerminated(
          TransactionTerminatedEvent transactionTerminatedEvent)
  {
    //view.getTxtArea().append("processTransactionTerminated\n"); 
  }

  @Override
  public void processDialogTerminated(
          DialogTerminatedEvent dialogTerminatedEvent)
  {
    //view.getTxtArea().append("processDialogTerminated\n"); 
  }

  @Override
  public void processDialogTimeout(DialogTimeoutEvent timeoutEvent)
  {
    //view.getTxtArea().append("processDialogTerminated\n"); 
  }
}