public void handleIncomingUpdate(Request msg) throws DialogStateException {
    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();
    assert !done.get();

    if (!done.get()) {
      Logger.log("Remote party has sent update");

      final Dialog dialog = getStackContext().getDialogStorage().findDialogForMessage(msg);
      assert dialog != null;

      checkUpdatePreconditions(dialog, msg);

      Logger.log(TAG, "mark dialog as update in progress");
      dialog.markUpdateInProgress(InitiateParty.REMOTE);

      // TransactionType<InviteSrvTransaction, ? extends ServerCommonInviteTransaction>
      // transactionType = SIP_REINVITE_SERVER;
      TransactionType<UpdateSrvTransaction, UpdateServerTransaction> transactionType =
          SIP_UPDATE_SERVER;

      doHandleIncomingUpdate(msg, dialog, transactionType);
    }
  }
  /** Shutdowns the service */
  public void shutdown() {
    Logger.log(getClass(), Logger.Tag.SHUTDOWN, "Shutdowning InviteService");
    if (done.compareAndSet(false, true)) {

      unSubscribeFromTransactionManager();
    }
    Logger.log(getClass(), Logger.Tag.SHUTDOWN, "InviteService shutdown successfully");
  }
  /**
   * Handles server noninvite message
   *
   * @param msg - noninvite message
   */
  public void handleIncomingBye(final Request msg) {

    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();
    assert !done.get();
    assert msg != null && MessageType.SIP_BYE == MessageType.parse(msg.getMethod());

    Logger.log("Remote party has sent noninvite");
    if (!done.get()) {

      final Dialog dialog = getStackContext().getDialogStorage().findDialogForMessage(msg);
      assert dialog != null;
      assert STATED == dialog.getState();

      dialog.getMessageHistory().addMessage(msg, true);

      final TransactionManager transactionManager = getTransactionManager();
      transactionManager.addListener(
          new FirstMessageResolver(SIP_BYE_SERVER.getName(), dialog, msg, transactionManager));

      final Transaction transaction =
          transactionManager.lookUpTransaction(dialog, null, SIP_BYE_SERVER);
      runAsynchronously(transaction, TRANSACTION_TIMEOUT);
    }
  }
  /**
   * Handles server invite message
   *
   * @param msg - invite message
   */
  public void handleIncomingInvite(final Request msg) throws DialogStateException {
    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();

    assert !done.get();
    assert msg != null && MessageType.SIP_INVITE == MessageType.parse(msg.getMethod());

    if (!done.get()) {
      Logger.log("Remote party has sent invite");
      // ClientIdentity localParty =
      // getStackContext().getStackClientRegistry().findAddressee(msg.getTo().getUriBuilder().getShortURI());
      ClientIdentity localParty = getStackContext().getClientRouter().findAddressee(msg);
      if (localParty != null) {
        assert getStackContext().getDialogStorage().findDialogForMessage(msg) == null;
        final Dialog dialog =
            getStackContext().getDialogStorage().getDialogForIncomingMessage(localParty, msg);
        TransactionType<InviteSrvTransaction, ? extends ServerCommonInviteTransaction>
            transactionType = SIP_INVITE_SERVER;

        doHandleIncomingInvite(msg, dialog, transactionType);
      } else {
        throw new DialogStateException(null, DialogStateException.Error.ADDRESSEE_NOT_FOUND, msg);
      }
    }
  }
  public void reInvite(final Dialog dialog) throws DialogStateException {
    Logger.log(TAG, "reInvite#started");
    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();
    assert !done.get();
    assert getStackContext().getDialogStorage().findDialogByCallId(dialog.getCallId()) != null
        : "DIALOG being re-invited is already  terminated";

    if (!done.get()) {

      checkReInvitePreconditions(dialog, null);
      dialog
          .getOutgoingSdpMessage()
          .setSessionVersion(dialog.getOutgoingSdpMessage().getSessionVersion() + 1);
      doReInvite(dialog, LONG_TRANSACTION_TIMEOUT);
    }
    Logger.log(TAG, "reInvite#finished");
  }
  private void preAccept(final Dialog dialog) {
    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();
    assert !done.get();
    Logger.log(TAG, "preAccept");

    if (!done.get()) {
      doPreAccept(dialog);
    }
  }
  /**
   * Cancels establishing DIALOG
   *
   * @param dialog - DIALOG to cancel
   */
  public void cancel(final Dialog dialog) {
    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();
    assert !done.get();
    Logger.log("Canceling call");

    if (!done.get()) {
      doCancel(dialog);
    }
  }
  /** This method tries to invite remote party */
  public void invite(final Dialog dialog) throws DialogStateException {
    Logger.log(TAG, "invite#started");
    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();
    assert !done.get();

    if (!done.get()) {
      if (STATED == dialog.getState()) {
        throw new DialogStateException(
            dialog,
            INVITE_FOR_STATED_DIALOG,
            null,
            "Can not invite remote party. Dialog is already stated.");
      }

      if (getStackContext().getConfig().useInviteRefresh()) {
        addDialogStateListener(dialog, listenerForInviteRefresh);
      }
      doInvite(dialog, LONG_TRANSACTION_TIMEOUT);
    }
    Logger.log(TAG, "invite#finished");
  }
  public void handleIncomingCancel(Request msg) throws DialogStateException {
    assert !done.get();
    assert msg != null && MessageType.SIP_CANCEL == MessageType.parse(msg.getMethod());

    if (!done.get()) {
      Logger.log("Remote party has sent SIP_CANCEL");

      final Dialog dialog = getStackContext().getDialogStorage().findDialogForMessage(msg);

      if (dialog != null) {
        dialog.getMessageHistory().addMessage(msg, true);

        final InviteSrvTransaction transaction =
            getTransactionManager().findTransaction(dialog, SIP_INVITE_SERVER);

        if (transaction != null) {
          final DialogStateEvent<BaseSipMessage> stateEvent =
              new DefaultDialogStateEvent<BaseSipMessage>(
                  dialog, SessionState.SESSION_TERMINATED, msg);

          dialogStateListenerHolder.getNotifier().onSessionTerminated(stateEvent);
          dialogStateListenerHolder.getNotifier().onSessionEnded(stateEvent);
          // DIALOG.putCustomParameter(ParamKey.INITIAL_MESSAGE, ((Transaction)
          // transaction).getInitialMessage());

          transaction.cancel();
        } else {
          // assert false : "Transaction already terminated for msg: " + msg.shortDescription() + "
          // dialog: " + dialog;
          throw new DialogStateException(
              dialog, DialogStateException.Error.REQUEST_FOR_UNKNOWN_DIALOG, msg);
        }
      } else {
        // assert false : "Dialog is already terminated or never exist. Message :" +
        // msg.shortDescription();
        throw new DialogStateException(
            dialog, DialogStateException.Error.REQUEST_FOR_UNKNOWN_DIALOG, msg);
      }
    }
  }
  private void doHandleIncomingInvite(
      final Request msg,
      final Dialog dialog,
      final TransactionType<InviteSrvTransaction, ? extends ServerCommonInviteTransaction>
          transactionType) {

    dialog.getMessageHistory().addMessage(msg, true);
    // DIALOG.putCustomParameter(ParamKey.LAST_MESSAGE, msg);
    Logger.log("doHandleIncomingInvite", "");
    SdpMessage sdp = SipMessageUtils.getSdpFromMessage(msg);
    if (sdp != null) {
      dialog.setIncomingSdpMessage(sdp);
    }

    final TransactionManager transactionManager = getTransactionManager();
    transactionManager.addListener(
        new FirstMessageResolver(transactionType.getName(), dialog, msg, transactionManager));

    final InviteSrvTransaction transaction =
        transactionManager.lookUpTransaction(dialog, null, transactionType);
    runAsynchronously((Transaction<Boolean, BaseSipMessage>) transaction);
  }
  public void handleIncomingReInvite(final Request msg) throws DialogStateException {
    assert TransactionUtils.isTransactionExecutionThread()
        : "Code run in wrong thread. Must be run in TransactionThread. Now in "
            + Thread.currentThread();
    assert !done.get();
    assert msg != null && MessageType.SIP_INVITE == MessageType.parse(msg.getMethod());

    if (!done.get()) {
      Logger.log("Remote party has sent ReInvite");

      final Dialog dialog = getStackContext().getDialogStorage().findDialogForMessage(msg);
      assert dialog != null;

      checkReInvitePreconditions(dialog, msg);
      dialog.markReInviteInProgress(InitiateParty.REMOTE);

      TransactionType<InviteSrvTransaction, ? extends ServerCommonInviteTransaction>
          transactionType = SIP_REINVITE_SERVER;

      doHandleIncomingInvite(msg, dialog, transactionType);
    }
  }