public WebSocket(SessionThread sessionThread, InternalConnectionOptions options, string serverAddress, StreamListener streamListener, ConnectionListener connListener)
{
this.sessionThread = sessionThread;
this.options = options;
if (TransportFactory <WebSocketProvider> .DefaultWebSocketFactory == null)
{
/* Note:
* this is a temporary hack. If the WebSocket support is not available, the transport uses a void implementation
* which just ignores the requests.
* The goal is to emulate the behavior of the old (non TLCP) Android compact client.
* That client doesn't support WebSocket, so when a user forces WebSocket transport
* the client simply ignores the requests.
* In the future we must address this question and work out a more user-friendly API behavior.
*/
this.wsClient = new DummyWebSocketClient();
}
else
{
this.wsClient = TransportFactory <WebSocketProvider> .DefaultWebSocketFactory.getInstance(sessionThread);
}
this.sessionListener = new MySessionRequestListener(sessionThread, streamListener, connListener);
open(serverAddress, streamListener, connListener);
if (log.IsDebugEnabled)
{
log.Debug("WebSocket transport - : " + sessionListener.state);
}
}
public RequestTutor(long currentTimeout, SessionThread thread, InternalConnectionOptions connectionOptions, bool fixedTO)
{
try
{
this.sessionThread = thread;
this.connectionOptions = connectionOptions;
this.session = sessionThread.SessionManager.Session;
this.serverSession = sessionThread.SessionManager.ServerSession;
if (fixedTO)
{
this.timeoutMs = this.FixedTimeout;
}
else
{
this.timeoutMs = currentTimeout > 0 ? currentTimeout * 2 : MIN_TIMEOUT;
}
}
catch (Exception e)
{
log.Warn("warn - " + e.Message);
if (log.IsDebugEnabled)
{
log.Debug(e.StackTrace);
}
}
}
internal HttpRequestManager(SessionThread thread, Transport transport, InternalConnectionOptions options) : this(thread, null, transport, options, null)
{
if (!InstanceFieldsInitialized)
{
InitializeInstanceFields();
InstanceFieldsInitialized = true;
}
}
public LightstreamerEngine(InternalConnectionOptions options, SessionThread sessionThread, EventsThread eventsThread, ClientListener listener, SessionManager manager)
{
this.connectionOptions = options;
this.sessionThread = sessionThread;
this.clientListener = listener;
this.eventsThread = eventsThread;
this.sessionManager = manager;
manager.SessionsListener = new SessionsListenerImpl(this);
}
public ReverseHeartbeatTimer(SessionThread sessionThread, InternalConnectionOptions options)
{
// // Debug.Assert(Assertions.SessionThread);
this.sessionThread = sessionThread;
this.options = options;
this.maxIntervalMs = options.ReverseHeartbeatInterval;
if (log.IsDebugEnabled)
{
log.Debug("rhb max interval " + maxIntervalMs);
}
CurrentInterval = maxIntervalMs;
}
internal HttpRequestManager(SessionThread thread, Protocol protocol, Transport transport, InternalConnectionOptions options, FatalErrorListener errListener)
{
if (!InstanceFieldsInitialized)
{
InitializeInstanceFields();
InstanceFieldsInitialized = true;
}
this.sessionThread = thread;
this.transport = transport;
this.protocol = protocol;
this.options = options;
this.errorListener = errListener;
}
internal SubscriptionManager(SessionThread sessionThread, SessionManager manager, InternalConnectionOptions options)
{
if (!InstanceFieldsInitialized)
{
InitializeInstanceFields();
InstanceFieldsInitialized = true;
}
this.sessionThread = sessionThread;
this.options = options;
this.manager = manager;
manager.SubscriptionsListener = this.eventsListener;
}
private void InitializeInstanceFields()
{
dispatcher = new EventDispatcher <ClientListener>(eventsThread);
internalListener = new InternalListener(this);
internalConnectionDetails = new InternalConnectionDetails(dispatcher);
internalConnectionOptions = new InternalConnectionOptions(dispatcher, internalListener);
manager = new SessionManager(internalConnectionOptions, internalConnectionDetails, sessionThread);
engine = new LightstreamerEngine(internalConnectionOptions, sessionThread, eventsThread, internalListener, manager);
messages = new MessageManager(eventsThread, sessionThread, manager, internalConnectionOptions);
subscriptions = new SubscriptionManager(sessionThread, manager, internalConnectionOptions);
// mpnManager = new MpnManager(manager, this, sessionThread);
connectionOptions = new ConnectionOptions(internalConnectionOptions);
connectionDetails = new ConnectionDetails(internalConnectionDetails);
}
internal MessageManager(EventsThread eventsThread, SessionThread sessionThread, SessionManager manager, InternalConnectionOptions options)
{
if (!InstanceFieldsInitialized)
{
InitializeInstanceFields();
InstanceFieldsInitialized = true;
}
this.sessionThread = sessionThread;
this.manager = manager;
this.options = options;
this.dispatcher = new EventDispatcher <ClientMessageListener>(eventsThread);
manager.MessagesListener = this.eventsListener;
}
public SubscriptionsTutor(SubscriptionManager outerInstance, long currentTimeout, SessionThread thread, InternalConnectionOptions connectionOptions) : base(currentTimeout, thread, connectionOptions, outerInstance.fixedTimeout > 0)
{
this.outerInstance = outerInstance;
}
public BindSessionRequest(string targetServer, string session, bool polling, string cause, InternalConnectionOptions options, long delay, bool addContentLength, long maxReverseHeartbeatIntervalMs) : base(polling, delay)
{
this.Server = targetServer;
Session = session;
// the session ID can still be omitted from the request, depending on the transport
if (polling)
{
this.addParameter("LS_polling", "true");
this.addParameter("LS_polling_millis", options.PollingInterval + delay);
this.addParameter("LS_idle_millis", options.IdleTimeout);
}
else
{
if (options.KeepaliveInterval > 0)
{
this.addParameter("LS_keepalive_millis", options.KeepaliveInterval);
}
if (maxReverseHeartbeatIntervalMs > 0)
{
this.addParameter("LS_inactivity_millis", maxReverseHeartbeatIntervalMs);
}
if (addContentLength)
{
this.addParameter("LS_content_length", options.ContentLength);
}
}
if (!string.ReferenceEquals(cause, null))
{
this.addParameter("LS_cause", cause);
}
}
public TextProtocolHttp(int objectId, SessionThread thread, InternalConnectionOptions options, Http httpTransport) : base(objectId, thread, options, httpTransport)
{
}
public TextProtocolWS(int objectId, SessionThread thread, InternalConnectionOptions options, InternalConnectionDetails details, Http httpTransport) : base(objectId, thread, options, httpTransport)
{
wsRequestManager = new WebSocketRequestManager(thread, this, options);
}
public VoidTutor(SessionThread thread, InternalConnectionOptions connectionOptions) : base(thread, connectionOptions)
{
}
internal ConnectionOptions(InternalConnectionOptions @internal)
{
this.@internal = @internal;
}
public RequestTutor(SessionThread thread, InternalConnectionOptions connectionOptions) : this(0, thread, connectionOptions, false)
{
}
public ChangeSubscriptionTutor(SubscriptionManager outerInstance, long currentTimeout, SessionThread thread, InternalConnectionOptions connectionOptions, ChangeSubscriptionRequest request) : base(outerInstance, currentTimeout, thread, connectionOptions)
{
this.outerInstance = outerInstance;
this.request = request;
}
public WebSocketRequestManager(SessionThread sessionThread, Protocol protocol, InternalConnectionOptions options)
{
this.options = options;
this.sessionThread = sessionThread;
this.protocol = protocol;
}
