start method

Future<void> start(UaSettings uaSettings)

Implementation

Future<void> start(UaSettings uaSettings) async {
  if (_ua != null) {
    logger.w('UA instance already exist!, stopping UA and creating a one...');
    _ua!.stop();
  }

  _uaSettings = uaSettings;

  // Reset settings
  _settings = Settings();
  WebSocketInterface socket = WebSocketInterface(uaSettings.webSocketUrl,
      messageDelay: _settings.sip_message_delay,
      webSocketSettings: uaSettings.webSocketSettings);
  _settings.sockets = <WebSocketInterface>[socket];
  _settings.uri = uaSettings.uri;
  _settings.sip_message_delay = uaSettings.sip_message_delay;
  _settings.realm = uaSettings.realm;
  _settings.password = uaSettings.password;
  _settings.ha1 = uaSettings.ha1;
  _settings.display_name = uaSettings.displayName;
  _settings.authorization_user = uaSettings.authorizationUser;
  _settings.user_agent = uaSettings.userAgent ?? DartSIP_C.USER_AGENT;
  _settings.register = uaSettings.register;
  _settings.register_expires = uaSettings.register_expires;
  _settings.register_extra_contact_uri_params =
      uaSettings.registerParams.extraContactUriParams;
  _settings.dtmf_mode = uaSettings.dtmfMode;
  _settings.session_timers = uaSettings.sessionTimers;
  _settings.ice_gathering_timeout = uaSettings.iceGatheringTimeout;

  try {
    _ua = UA(_settings);
    _ua!.on(EventSocketConnecting(), (EventSocketConnecting event) {
      logger.d('connecting => $event');
      _notifyTransportStateListeners(
          TransportState(TransportStateEnum.CONNECTING));
    });

    _ua!.on(EventSocketConnected(), (EventSocketConnected event) {
      logger.d('connected => $event');
      _notifyTransportStateListeners(
          TransportState(TransportStateEnum.CONNECTED));
    });

    _ua!.on(EventSocketDisconnected(), (EventSocketDisconnected event) {
      logger.d('disconnected => ${event.cause}');
      _notifyTransportStateListeners(TransportState(
          TransportStateEnum.DISCONNECTED,
          cause: event.cause));
    });

    _ua!.on(EventRegistered(), (EventRegistered event) {
      logger.d('registered => ${event.cause}');
      _registerState = RegistrationState(
          state: RegistrationStateEnum.REGISTERED, cause: event.cause);
      _notifyRegistrationStateListeners(_registerState);
    });

    _ua!.on(EventUnregister(), (EventUnregister event) {
      logger.d('unregistered => ${event.cause}');
      _registerState = RegistrationState(
          state: RegistrationStateEnum.UNREGISTERED, cause: event.cause);
      _notifyRegistrationStateListeners(_registerState);
    });

    _ua!.on(EventRegistrationFailed(), (EventRegistrationFailed event) {
      logger.d('registrationFailed => ${event.cause}');
      _registerState = RegistrationState(
          state: RegistrationStateEnum.REGISTRATION_FAILED,
          cause: event.cause);
      _notifyRegistrationStateListeners(_registerState);
    });

    _ua!.on(EventNewRTCSession(), (EventNewRTCSession event) {
      logger.d('newRTCSession => $event');
      RTCSession session = event.session!;
      if (session.direction == 'incoming') {
        // Set event handlers.
        session.addAllEventHandlers(
            buildCallOptions()['eventHandlers'] as EventManager);
      }
      _calls[event.id] =
          Call(event.id, session, CallStateEnum.CALL_INITIATION);
      _notifyCallStateListeners(
          event, CallState(CallStateEnum.CALL_INITIATION));
    });

    _ua!.on(EventNewMessage(), (EventNewMessage event) {
      logger.d('newMessage => $event');
      //Only notify incoming message to listener
      if (event.message!.direction == 'incoming') {
        SIPMessageRequest message =
            SIPMessageRequest(event.message, event.originator, event.request);
        _notifyNewMessageListeners(message);
      }
    });

    _ua!.start();
  } catch (event, s) {
    logger.e(event.toString(), null, s);
  }
}