Interface SubscriptionListener
Interface to be implemented to listen to Subscription
events comprehending notifications of subscription/unsubscription,
updates, errors and others.
Events for this listeners are executed asynchronously with respect to the code that generates them.
This means that, upon reception of an event, it is possible that the internal state of the client has changed.
On the other hand, all the notifications for a single LightstreamerClient, including notifications to
ClientListeners, SubscriptionListeners and ClientMessageListeners will be dispatched by the
same thread.
Namespace: com.lightstreamer.client
Assembly: Lightstreamer.DotNetStandard.Client.Api.dll
Syntax
public interface SubscriptionListener
Methods
onClearSnapshot(string, int)
Event handler that is called by Lightstreamer each time a request to clear the snapshot pertaining to an item in the Subscription has been received from the Server. More precisely, this kind of request can occur in two cases:
- For an item delivered in COMMAND mode, to notify that the state of the item becomes empty; this is equivalent to receiving an update carrying a DELETE command once for each key that is currently active.
- For an item delivered in DISTINCT mode, to notify that all the previous updates received for the item should be considered as obsolete; hence, if the listener were showing a list of recent updates for the item, it should clear the list in order to keep a coherent view.
Subscription.CommandSecondLevelFields
and Subscription.CommandSecondLevelFieldSchema
)
, the notification refers to the first-level item (which is in COMMAND mode).
This kind of notification is not possible for second-level items (which are in MERGE
mode).
Declaration
void onClearSnapshot(string itemName, int itemPos)
Parameters
Type | Name | Description |
---|---|---|
string | itemName | name of the involved item. If the Subscription was initialized using an "Item Group" then a null value is supplied. |
int | itemPos | 1-based position of the item within the "Item List" or "Item Group". |
onCommandSecondLevelItemLostUpdates(int, string)
Event handler that is called by Lightstreamer to notify that, due to internal resource limitations,
Lightstreamer Server dropped one or more updates for an item that was subscribed to as a second-level subscription.
Such notifications are sent only if the Subscription was configured in unfiltered mode (second-level items are
always in "MERGE" mode and inherit the frequency configuration from the first-level Subscription).
By implementing this method it is possible to perform recovery actions.
Declaration
void onCommandSecondLevelItemLostUpdates(int lostUpdates, string key)
Parameters
Type | Name | Description |
---|---|---|
int | lostUpdates | The number of consecutive updates dropped for the item. |
string | key | The value of the key that identifies the second-level item. |
onCommandSecondLevelSubscriptionError(int, string, string)
Event handler that is called when the Server notifies an error on a second-level subscription.
By implementing this method it is possible to perform recovery actions.
Declaration
void onCommandSecondLevelSubscriptionError(int code, string message, string key)
Parameters
Type | Name | Description |
---|---|---|
int | code | The error code sent by the Server. It can be one of the following:
|
string | message | The description of the error sent by the Server; it can be null. |
string | key | The value of the key that identifies the second-level item. |
onEndOfSnapshot(string, int)
Event handler that is called by Lightstreamer to notify that all snapshot events for an item in the
Subscription have been received, so that real time events are now going to be received. The received
snapshot could be empty. Such notifications are sent only if the items are delivered in DISTINCT or COMMAND
subscription mode and snapshot information was indeed requested for the items. By implementing this
method it is possible to perform actions which require that all the initial values have been received.
Note that, if the involved Subscription has a two-level behavior enabled
(see Subscription.CommandSecondLevelFields
and Subscription.CommandSecondLevelFieldSchema
)
, the notification refers to the first-level item (which is in COMMAND mode).
Snapshot-related updates for the second-level items
(which are in MERGE mode) can be received both before and after this notification.
Declaration
void onEndOfSnapshot(string itemName, int itemPos)
Parameters
Type | Name | Description |
---|---|---|
string | itemName | name of the involved item. If the Subscription was initialized using an "Item Group" then a null value is supplied. |
int | itemPos | 1-based position of the item within the "Item List" or "Item Group". |
onItemLostUpdates(string, int, int)
Event handler that is called by Lightstreamer to notify that, due to internal resource limitations, Lightstreamer Server dropped one or more updates for an item in the Subscription. Such notifications are sent only if the items are delivered in an unfiltered mode; this occurs if the subscription mode is:
- RAW
- MERGE or DISTINCT, with unfiltered dispatching specified
- COMMAND, with unfiltered dispatching specified
- COMMAND, without unfiltered dispatching specified (in this case, notifications apply to ADD and DELETE events only)
Declaration
void onItemLostUpdates(string itemName, int itemPos, int lostUpdates)
Parameters
Type | Name | Description |
---|---|---|
string | itemName | name of the involved item. If the Subscription was initialized using an "Item Group" then a null value is supplied. |
int | itemPos | 1-based position of the item within the "Item List" or "Item Group". |
int | lostUpdates | The number of consecutive updates dropped for the item. |
onItemUpdate(ItemUpdate)
Event handler that is called by Lightstreamer each time an update pertaining to an item in the Subscription has been received from the Server. The updated values for all the fields are contained in a value object of type ItemUpdate.
Declaration
void onItemUpdate(ItemUpdate itemUpdate)
Parameters
Type | Name | Description |
---|---|---|
ItemUpdate | itemUpdate | a value object containing the updated values for all the fields, together with meta-information about the update itself and some helper methods that can be used to iterate through all or new values. |
onListenEnd()
Event handler that receives a notification when the SubscriptionListener instance is removed from a Subscription
through Subscription.removeListener
. This is the last event to be fired on the listener.
Declaration
void onListenEnd()
onListenStart()
Event handler that receives a notification when the SubscriptionListener instance is added to a Subscription
through Subscription.addListener
. This is the first event to be fired on the listener.
Declaration
void onListenStart()
onRealMaxFrequency(string)
Event handler that is called by Lightstreamer to notify the client with the real maximum update frequency of the Subscription.
It is called immediately after the Subscription is established and in response to a requested change
(see Subscription.requestedMaxFrequency
).
Since the frequency limit is applied on an item basis and a Subscription can involve multiple items,
this is actually the maximum frequency among all items. For Subscriptions with two-level behavior
(see Subscription.CommandSecondLevelFields
and Subscription.CommandSecondLevelFieldSchema
)
, the reported frequency limit applies to both first-level and second-level items.
The value may differ from the requested one because of restrictions operated on the server side,
but also because of number rounding.
Note that a maximum update frequency (that is, a non-unlimited one) may be applied by the Server
even when the subscription mode is RAW or the Subscription was done with unfiltered dispatching.
Declaration
void onRealMaxFrequency(string frequency)
Parameters
Type | Name | Description |
---|---|---|
string | frequency | A decimal number, representing the maximum frequency applied by the Server (expressed in updates per second), or the string "unlimited". A null value is possible in rare cases, when the frequency can no longer be determined. |
onSubscription()
Event handler that is called by Lightstreamer to notify that a Subscription has been successfully subscribed
to through the Server. This can happen multiple times in the life of a Subscription instance, in case the
Subscription is performed multiple times through LightstreamerClient.unsubscribe
and
LightstreamerClient.subscribe
. This can also happen multiple times in case of automatic
recovery after a connection restart.
This notification is always issued before the other ones related to the same subscription. It invalidates all
data that has been received previously.
Note that two consecutive calls to this method are not possible, as before a second onSubscription event is
fired an onUnsubscription() event is eventually fired.
If the involved Subscription has a two-level behavior enabled
(see Subscription.CommandSecondLevelFields
and Subscription.CommandSecondLevelFieldSchema
)
, second-level subscriptions are not notified.
Declaration
void onSubscription()
onSubscriptionError(int, string)
Event handler that is called when the Server notifies an error on a Subscription. By implementing this method it
is possible to perform recovery actions.
Note that, in order to perform a new subscription attempt, LightstreamerClient.unsubscribe
and LightstreamerClient.subscribe
should be issued again, even if no change to the Subscription
attributes has been applied.
Declaration
void onSubscriptionError(int code, string message)
Parameters
Type | Name | Description |
---|---|---|
int | code | The error code sent by the Server. It can be one of the following:
|
string | message | The description of the error sent by the Server; it can be null. |
onUnsubscription()
Event handler that is called by Lightstreamer to notify that a Subscription has been successfully unsubscribed
from. This can happen multiple times in the life of a Subscription instance, in case the Subscription is performed
multiple times through LightstreamerClient.unsubscribe(Subscription)
and
LightstreamerClient.subscribe(Subscription)
. This can also happen multiple times in case of automatic
recovery after a connection restart.
After this notification no more events can be received until a new onSubscription() event.
Note that two consecutive calls to this method are not possible, as before a second onUnsubscription event
is fired an onSubscription() event is eventually fired.
If the involved Subscription has a two-level behavior enabled
(see Subscription.CommandSecondLevelFields
and Subscription.CommandSecondLevelFieldSchema
)
, second-level unsubscriptions are not notified.
Declaration
void onUnsubscription()