 |
|
|
Featured Demos
|
|
|
|
Other Demos
|
|
|
|
Demo Details
|
Below is the detailed information on each demo.
|
|
| |
Please bear in mind that these demos are
not intended to show full-blown applications,
but to focus on specific aspects of Lightstreamer with a
didactic purpose. For this reason, they are kept extremely simple.
All of the demos work without an application server. In other words,
they are so simple that they don't need any server-side logic, except for
the Lightstreamer Adapters. Even the HTML front-ends are completely static
(not generated through JSP, ASP, PHP, etc.).
|
| |
|
|
|
|
This demo displays real-time market data for ten stocks, generated by a feed
simulator.
This page uses the HTML Client API for Lightstreamer to handle the communications with
Lightstreamer Server. A simple user interface is implemented to display the real-time
data received from Lightstreamer Server.
The front-end code is kept extremely simple and represents a good
introduction to Lightstreamer table management. In particular, the client code can be
considered as a reference example of item subscriptions in MERGE mode.
Tables involved:
Adapters involved:
- QUOTE_ADAPTER: a sample Data Adapter generating random market
data.
- LiteralBasedProvider: a sample Metadata Adapter that can be used
out-of-the-box for many types of applications.
Client source code (folder of Lightstreamer distribution):
- pages/demos/StockListDemo_Basic
QUOTE_ADAPTER source code (folders of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/StockListDemo_DataAdapter
- Java-with-JMS version:
DOCS-SDKs/sdk_adapter_java/examples/StockListDemo_JMS_DataAdapter
- C#.NET version:
DOCS-SDKs/sdk_adapter_dotnet/examples/Remote_StockListDemo_Adapters/
src_data_adapter
LiteralBasedProvider source code (folders of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Reusable_MetadataAdapters/src_adapters
- C#.NET version:
DOCS-SDKs/sdk_adapter_dotnet/examples/Remote_StockListDemo_Adapters/
src_metadata_adapter
|
|
|
|
This demo shows some further features with respect to the Basic Stock-List Demo.
Click on the stock names to open pop-up windows that display real-time streaming charts.
Notice that the maximum update frequency set for the pop-up windows is greater than the
frequency set for the main window. The data is resampled by Lightstreamer Server according
to the maximum frequency requested by each table (you can easily notice that if you open
"Ations Europe").
Click on the link under the table (Next/Previous 15) to dynamically switch
between two lists of fifteen items, without losing previously opened pop-ups. If you open
the same demo in different browser windows, you will see slightly different values for the
most updated stocks. Agais, this behavior shows how the data resampling is done in real-time
on a per-window basis.
Notice that a large portion of the JavaScript front-end code is devoted to client-side formatting operations.
Tables involved:
Adapters involved:
Client source code (folder of Lightstreamer distribution):
- pages/demos/StockListDemo
|
|
|
|
The same as the Stock-List Demo, but with a different architecture
for the LightstreamerEngine integration. The LightstreamerEngine object is kept in a hidden Master
Push-Page. For an explanation of the different deployment strategies please refer to the
"Web Client Dev.pdf" document.
Tables involved:
Adapters involved:
Client source code (folder of Lightstreamer distribution):
- pages/demos/StockListDemo_Frames
|
|
|
|
This demo shows the advanced bandwidth management feature of Lightstreamer.
Use the "Bandwidth Limit" slider to dynamically change the maximum bandwidth. The client will notify
the server the new bandwidth and the server will change the update frequency on the fly, to always
respect the bandwidth limit. Note that thanks to MERGE mode, the updates are not queued and delayed,
but resampled and conflated. In other words, when an item has a chance to be updated (based on a
round-robin algorithm), it will receive the very latest state available, not an old one.
You can see that with a bandwidth as ridiculous as 0.5 kilobits per seconds, Lightstreamer is
still able to deliver updates to the page, thanks to the very optimized network protocol used.
With the "Highlight Color" slider you can change the background color of the updated cells on the fly
(use the red, green and blue handles).
Click on the link under the table (Next/Previous 15) to dynamically switch between two lists of
fifteen items and see how the initial snapshot is loaded still respecting the bandwidth limit.
Tables involved:
Adapters involved:
Client source code:
- view the page source
|
|
|
|
This demo shows how it is possible to build a dynamic "grid" by leveraging some Lightstreamer visual
tables (OverwriteTables).
The 30 items of the Stock-List Demo are virtually contained in the
grid, but only 5 at a time are displayed. The slider to the right implements a virtual scroll bar.
When the table is scrolled, the invisible items are unsubscribed from and the new visible items
are subscribed to. To accomplish this, each Lightstreamer table (an OverwriteTable) contains one
item only (i.e. each row on the screen is a Lightstreamer table), so that the granularity of
subscriptions and unsubscriptions is at the row level.
This technique enables to handle visual grids containing thousands of items with a very low impact
on both the client side and the server side.
Notice the use of
ScreenTableHelper
to optimize the HTML scan.
Tables involved:
- An OverwriteTable
for each visible row, containing 1 item, subscribed to in MERGE mode.
So, 5 OverwiteTables are used in this example.
Adapters involved:
Client source code:
- view the page source
|
|
|
|
This demo shows the capability of Lightstreamer to plot some simple real-time streaming charts
in pure HTML and JavaScript. This feature is also demonstrated in the pop-up windows of the
Stock-List Demo. For more sophisticated charts, it is possible
to use third-party charting libraries.
In this chart, the prices for two stocks are normalized to 100 and plotted.
Tables involved:
- An OverwriteTable
containing 2 items, subscribed to in MERGE mode.
- A ChartTable
containing 2 items, subscribed to in MERGE mode.
Adapters involved:
Client source code:
- view the page source
|
|
|
|
In the Basic Portfolio Demo, a virtual stock portfolio, shared among all the connected users,
is displayed.
By using the "Submit Order" panel, you can buy or sell a stock (identified by an
item number), filling in the Quantity field and pressing the proper button.
Click on the column headers to sort the table on different columns.
The portfolio table is updated in push mode, for both the columns and the rows (this is the so
called "metapush" feature).
This portfolio is shared among all the connected users, so you can connect to this demo
from different machines (or try at least different browsers on the same machine), then submit
orders from one browser and see the updates displayed on another browser.
The front-end code can be considered a reference example of item subscriptions in COMMAND mode.
Please notice that to keep the code simple, the order submission is done by sending a message to
Lightstreamer Server directly. Real applications will usually deliver messages to an application
server, which will process them and in turn send them to the proper Lightstreamer Adapters through
some messaging middleware (e.g. JMS, RV, etc.).
Tables involved:
- A DynaMetapushTable
containing 1 item, subscribed to in COMMAND mode. Each row of the
table is identified by a unique key. For didactic purpose, this example displays the command and key
fields, which are usually hidden.
Adapters involved:
- PORTFOLIO_ADAPTER: a sample Data Adapter that manages a simulated
stock portfolio.
- PortfolioMetadataAdapter: a simple Metadata Adapter that inherits
from LiteralBasedProvider. It plays the extra-role of receiving order submissions from the clients
and forwarding them to the Data Adapter.
Client source code (folder of Lightstreamer distribution):
- pages/demos/PortfolioDemo_Basic
PORTFOLIO_ADAPTER source code (folders of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Portfolio_Adapters
- C#.NET version:
DOCS-SDKs/sdk_adapter_dotnet/examples/Remote_Portfolio_Adapters/
src_adapters
PortfolioMetadataAdapter source code (folders of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Portfolio_Adapters
- C#.NET version:
DOCS-SDKs/sdk_adapter_dotnet/examples/Remote_Portfolio_Adapters/
src_adapters
|
|
|
|
This demo application extends the Basic Portfolio Demo
by combining live stock prices (as in the Stock-List Demos)
with the portfolio contents.
The columns show: stock name, last price, quantity (number of stocks in the portfolio),
countervalue (=price*quantity), time of last price.
The portfolio content is the same as the Basic Portfolio Demo
(i.e. it subscribes to the same item from the same Data Adapter) and it is shared among all the
connected users. Again, you can connect to this demo from different machines and see your
operations propagated everywhere.
The front-end code can be considered a reference example of item subscriptions in COMMAND mode
with "two-level push".
The same considerations on the order submission technique as the
Basic Portfolio Demo apply.
Tables involved:
- A MultiDynaMetapushTable
containing 1 item, subscribed to in COMMAND mode. Each added row
automatically provokes an underlying subscription to a sub-item in MERGE
mode, to get the real-time price for that specific stock from another feed (the same as the
Stock-List Demos). When a row is deleted,
the underlying sub-item is automatically unsubscribed from.
Adapters involved:
Client source code (folder of Lightstreamer distribution):
- pages/demos/PortfolioDemo
|
|
|
|
This demo application shows a changeable list of items within a normal HTML drop-down menu.
The contents of the list change in real time, based on the commands pushed by the Server.
The feed that controls the list contents is the same as in the
Portfolio Demos (i.e. it subscribes to the same item from
the same Data Adapter) and it is shared among all the connected users. So, you can see the
drop-down menu kept in sync across all the browsers connected to this page.
The front-end code can be considered a reference example of item subscriptions through
non-visual tables, useful when the data visualization does not leverage the Lightstreamer
widgets, but uses custom HTML code or third-party widgets.
Tables involved:
- A NonVisualTable
containing 1 item, subscribed to in COMMAND mode.
Each time the Server sends an "add" or "delete" command, the JavaScript code manipulates
the drop-down menu to update its contents.
Adapters involved:
Client source code (folder of Lightstreamer distribution):
- pages/demos/DropDownDemo
|
|
|
|
The Basic Chat Demo implements an extremely simple chat application, where all the users
connected to the page can exchange messages. Each message reports the originating IP address,
together with the user-agent string of the originating client, instead of leveraging a nick name.
Launch multiple instances of the demo, possibly on different machines, to appreciate the message
broadcast capability.
The front-end code can be considered a reference example of item subscriptions in DISTINCT mode.
As in the Portfolio Demos, to keep the example simple and
deployable without a web/application server, the message submission is done by sending a message
to Lightstreamer Server directly.
Note: When you publish a value your IP address is publicly displayed.
Tables involved:
Adapters involved:
- CHAT_ROOM: a sample Data Adapter that publishes messages
on an item.
- ChatMetadataAdapter: a simple Metadata Adapter that inherits from
LiteralBasedProvider. It plays the extra-role of receiving messages from the clients and forwarding
them to the Data Adapter.
Client source code (folder of Lightstreamer distribution):
- pages/demos/ChatDemo
CHAT_ROOM source code (folder of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Chat_Adapters
ChatMetadataAdapter source code (folder of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Chat_Adapters
|
|
|
|
The Basic Instant Messenger Demo shows an extremely simple version of a typical messenger,
where messages can be delivered to a specific friend, chosen from a dynamic list of online buddies.
Choose a nick-name and click Login. You will see a list of all users connected to this demo, with their
nicknames. Write a message and choose a recipient. The message will be delivered only to him/her
(rather than broadcasting it, as the Basic Chat Demo does).
Launch multiple instances of the demo, possibly on different machines, to populate the Buddies list.
If you use the same nick-name on different instances, you will actually embody the same identity
(to keep things simple, no authentication is used).
The front-end code can be considered a reference example of one-to-one messaging. Each user
subscribes to their personal item (corresponding to the nick-name), so that messages can be routed
properly, instead of begin broadcast (as in the Basic Chat Demo,
where all the users subscribe to the same item). In real applications, where authentication
is used, the Metadata Adapter should enforce the association between the user's identity
and the item they have the right to subscribe to.
As in the Portfolio Demos, to keep the example simple and
deployable without a web/application server, the message submission is done by sending a message
to Lightstreamer Server directly.
Tables involved:
- A DynaScrollTable
containing 1 item, subscribed to in DISTINCT mode, to get all the
personal messages.
- A DynaMetapushTable
containing 1 item, subscribed to in COMMAND mode, to get the
updated buddy list.
Adapters involved:
- SIMPLE_MESSENGER: a sample Data Adapter that manages the personal
users' items and the item dedicated to the buddy list.
- IMMetadataAdapter: a simple Metadata Adapter that inherits
from LiteralBasedProvider. It plays the extra-role of receiving messages from the clients
and forwarding them to the Data Adapter.
Client source code (folder of Lightstreamer distribution):
- pages/demos/MessengerDemo
SIMPLE_MESSENGER source code (folder of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Chat_Adapters
IMMetadataAdapter source code (folder of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Chat_Adapters
|
|
|
|
The Round-Trip Demo lets you broadcast messages as yout type, character by character,
to all the browsers displaying that page.
Type anything in the 5 fields. Your characters will be delivered to the server, which
will send them back to all the browsers, including yours (in the bottom table).
Launch multiple instances of the demo, possibly on different browsers or different
machines, to really appreciate the broadcast capabilities. You will type some text
in a browser and see it appear in real time on another browser.
The table to the bottom reports the originating IP address and the timestamp of the
last change applied to each item.
As in the Portfolio Demos, to keep the example simple and
deployable without a web/application server, the message submission is done by sending a message
to Lightstreamer Server directly.
Note: When you publish a value your IP address is publicly displayed.
Tables involved:
Adapters involved:
- ROUNDTRIP_ADAPTER: a Data Adapter that broadcasts the values of
received from the Metadata Adapter for the 5 items in real time.
- RoundTripMetadataAdapter: a simple Metadata Adapter that inherits
from LiteralBasedProvider. It plays the extra-role of receiving messages from the clients
and forwarding them to the Data Adapter.
Client source code (folder of Lightstreamer distribution):
- view the page source
ROUNDTRIP_ADAPTER source code:
- N/A
RoundTripMetadataAdapter source code:
- N/A
|
|
|
|
This application shows a real-time monitor console. Several metrics are reported as they change on
the server.
Tables involved:
- Three OverwriteTables
containing the items for the statistics, subscribed to in MERGE mode.
Fields from a single item are associated to cells scattered in the page.
- Three DynaScrollTables
for the three scrolling log pane items, subscribed to in DISTINCT mode.
Adapters involved:
- MONITOR: an internal Data Adapter that reports monitoring data
on Lightstreamer Server itself. Of course, other monitoring applications will need their own
Data Adapter.
- MonitorDemo: a simple Metadata Adapter that inherits from
LiteralBasedProvider.
Client source code (folder of Lightstreamer distribution):
- pages/demos/MonitorDemo
MONITOR source code:
- N/A (it is embedded in Lightstreamer Server)
MonitorDemo source code (folder of Lightstreamer distribution):
- Java version:
DOCS-SDKs/sdk_adapter_java/examples/Monitor_MetadataAdapter
|
|
|
|
The Formula 1 Web Telemetry Demo shows how Lightstreamer can be used to send real-time telemetry
data through the Web.
In this demo, the data is generated by a feed simulator. Actual feed adapters were created
to deliver real data.
Tables involved:
- An OverwriteTable
containing 1 item, subscribed to in MERGE mode, with some of the metrics
pertaining to the car.
- A DynaScrollTable
containing 1 item, subscribed to in DISTINCT mode, with the data for
each lap.
- Two ChartTables
containing 1 item (the same as the OverwriteTable), subscribed to in MERGE
mode, used to plot the speed and the engine RPM.
Adapters involved:
- FORMULA1_ADAPTER: a Data Adapter that generates random data
for the telemetry metrics of the car.
- LiteralBasedProvider (see Basic Stock-List Demo).
Client source code:
- view the page source
FORMULA1_ADAPTER source code:
- N/A
|
|
|
|
The RSS News Reader Demo is a simple news aggregator that allows the user to subscribe to several RSS
feeds and have the news pushed in real-time without refreshing the page or polling the server
under the hood.
The demo starts with some feeds already subscribed to. You can add your own feeds or click
on "+" to add random feeds.
Tables involved:
- A DynaScrollTable
containing 1 item, subscribed to in DISTINCT mode, containing the news.
- A DynaMetapushTable
containing 1 item, subscribed to in COMMAND mode, containing the list
of feeds currently subscribed to.
Adapters involved:
- RSS_ADAPTER: a Data Adapter that polls all the feeds currently
subscribed to and delivers the updates to the Server. It also delivers the list of subscribed feeds
for each user.
- RSSMetadataAdapter: a simple Metadata Adapter that inherits
from LiteralBasedProvider. It coordinates, together with the Data Adapter, the association
among items, users, and subscribed feed.
Client source code (folder of Lightstreamer distribution):
- view the page source
RSS_ADAPTER source code:
- N/A
RSSMetadataAdapter source code:
- N/A
|
|
|
|
A version of the Stock-List Demo shrunk down to adapt to very small
screens. This is ideal to watch on old-generation mobile devices.
Tables involved:
Adapters involved:
Client source code:
- view the page source
|
|
|
|
A version of the Chart Demo shrunk down to adapt to very small
screens. This is ideal to watch on old-generation mobile devices.
Tables involved:
- An OverwriteTable
containing 1 item, subscribed to in MERGE mode.
- A ChartTable
containing 1 item, subscribed to in MERGE mode.
Adapters involved:
Client source code:
- view the page source
|
|
|
|
|
An integration demo of Lightstreamer and JQuery Grid Plugin.
This page uses the HTML Client API for Lightstreamer to handle the communications with
Lightstreamer Server and uses jqGrid to display the real-time data pushed by Lightstreamer Server.
A Lightstreamer NonVisualTable is used for subscribing to the data. The onItemUpdate callback
implementation acts as a bridge between Lightstreamer and jqGrid, by injecting the real-time
updates through the setRowData function.
Click on the Name column header to resort the stocks in the table.
Tables involved:
Adapters involved:
Client source code:
- download the zip file
|
|
|
|
An integration demo of Lightstreamer and Google Web Toolkit (GWT).
This page uses the HTML Client API for Lightstreamer to handle the communications with
Lightstreamer Server and uses a GWT FlexTable to display the real-time data pushed by Lightstreamer.
The LSGWTPushPage class wraps the PushPage and LightstreamerEngine objects, which are the
JavaScript classes responsible for handling connections and subscriptions.
The LSGWTNonVisualTable class wraps the NonVisualTable JavaScript class, which represents
a subscription. It is an abstract class; its subclass LSGWTDemoTable extends its
functionalities implementing the handling of the updates and publishing them to a
GWT FlexTable.
Tables involved:
Adapters involved:
Client source code:
- download the zip file
|
|
|
|
An integration demo of Lightstreamer and Dojo Toolkit.
This page uses the HTML Client API for Lightstreamer to handle the communications with
Lightstreamer Server; uses the LightstreamerStore, a JavaScript interface based on
the dojo.store APIs, as a bridge between Lightstreamer and Dojo APIs; and uses
dojox.grid.DataGrid and dojox.charting.Chart
to display the real-time data received from the Lightstreamer Server.
A detailed explanation
of this application and he integration approach is available.
Tables involved:
Adapters involved:
Client source code:
- download the zip file
|
|
|
|
A demonstration of simple integration between Lightstreamer and
TIBCO General Interface.
This application uses the HTML Client API for Lightstreamer to handle the communications with
Lightstreamer Server and uses the General Interface API to display the real-time data.
In this application, five stock quotes are displayed in real time. The demo page contains two tables,
both of which receive the real-time data flow from Lightstreamer Server. The table at the top
is managed by the Lightstreamer Web Client, though embedded inside GI. The table at the bottom is
a GI table (in which you can drag, resize and sort columns) and is updated by the Lightstreamer
Web Client. GI-based pop-up windows show the price charts produced by the Lightstreamer Web Client.
Tables involved:
- An OverwriteTable
containing 5 items, subscribed to in MERGE mode.
It is used both as a widget to display the data and as a bridge to inject the data into the GI widget.
- A ChartTable
for each pop-up window opened, containing one item, subscribed to in MERGE mode.
Adapters involved:
Client source code:
- download the zip file
(then see the included README.pdf)
|
|
|
|
This demo shows a complete integration between Lightstreamer and
TIBCO General Interface.
This application uses the HTML Client API for Lightstreamer to handle the communications with
Lightstreamer Server; uses PageBus as a brisge between Lightstreamer and General Interface APIs;
and uses the General Interface API to display the real-time data.
The Lightstreamer client receives events from Lightstreamer Server and publishes the stock
updates on TIBCO PageBus. The application, created with the GI Builder, subscribes to
the PageBus in order to receive and display the updates to the user.
A detailed explanation
of this application is available (in that document Lightstreamer is referred to as "Ajax Message Service").
Tables involved:
- A NonVisualTable
for each item added to the update panel, subscribed to in MERGE mode.
Adapters involved:
Client source code:
- download the zip file
(then see the included README.pdf)
|
|
|
|
An integration demo of Lightstreamer and Microsoft ASP.NET AJAX.
This application uses the HTML Client API for Lightstreamer to handle the communications with
Lightstreamer Server and uses an ASP.NET AJAX ReorderList to display the data for eight stock
quotes received from Lightstreamer Server.
You can drag the blue handles to reorder the list.
Click on the stock names to open pop-up boxes showing the streaming charts.
Tables involved:
- An OverwriteTable
containing 8 items, subscribed to in MERGE mode.
- A ChartTable
for each pop-up window opened, containing 1 item, subscribed to in MERGE
mode.
Adapters involved:
Client source code:
- N/A
|
|
|
|
The OpenAjax Hub, a key technology component by
OpenAjax Alliance, addresses Ajax application
scenarios where a Web application developer needs to use multiple Ajax runtime libraries
together within the same application.
This demo was used to pass the OpenAjax Alliance
InteropFest 1.0 test case.
The Lightstreamer HTML client API receives real-time events from Lightstreamer Server, displays them
through its visual component (OverwriteTable) and publishes them, on the client side, through
the Hub. A third-party component (the sample datavis component) subscribes to the events on the
Hub and displays them.
Tables involved:
Adapters involved:
Client source code:
- download the zip file
|
|
|
|
|
This very simple demo uses the Flash Bridge to inject real-time data into two Flash movies
hosted on the page. Each of the two movies subscribes to two items of the
Stock-List Demos.
The smaller movie sets a maximum update frequency of 1 event/sec.
The Flash app uses the ActionScript/JavaScript Bridge provided as part of the
"sdk_client_flash". That means the ActionScript API, used within the Flash
application, talk to external JavaScript API, that in turn use the
HTML Client API for Lightstreamer to handle the communications with Lightstreamer Server.
Tables involved:
- A
FlashTable
containing 2 items, subscribed to in MERGE mode,
for each Flash movie.
Adapters involved:
Client source code (folders of Lightstreamer distribution):
- HTML/JavaScript part:
pages/demos/Flash_StockListDemo_Basic
- Flash part:
DOCS-SDKs/sdk_client_flash/examples/FlashBasic
|
|
|
|
This is a Flash version of the Stock-List Demos,
which displays eight stock quotes with some nice graphic effects.
The Flash app uses the ActionScript/JavaScript Bridge provided as part of the
"sdk_client_flash". That means the ActionScript API, used within the Flash
application, talk to external JavaScript API, that in turn use the
HTML Client API for Lightstreamer to handle the communications with Lightstreamer Server.
Tables involved:
- A
FlashTable
containing 8 items, subscribed to in MERGE mode.
Adapters involved:
Client source code (folders of Lightstreamer distribution):
- HTML/JavaScript part:
pages/demos/Flash_StockListDemo
- Flash part:
DOCS-SDKs/sdk_client_flash/examples/FlashStockList
|
|
|
|
This is a Flex version of the Stock-List Demos,
where ten items are subscribed to.
This app uses the Flex Client API for Lightstreamer to handle the communications with
Lightstreamer Server and uses the Flex DataGrid to display the real-time data
pushed by Lightstreamer Server.
The upper table shows the automatic binding of a Lightstreamer data table to a Flex widget
(a DataGrid). You can sort on any columns and drag the columns around. The buttons to the right
control the update highlight effects and can stop/start the subscription.
The lower table shows the direct use of pushed values to manually update a Flex widget
(a TextArea). The buttons to the right can clear the TextArea and stop/start the subscription.
Tables involved:
- A
VisualTable
containing 10 items, subscribed to in MERGE mode, bound
to the Flex DataGrid.
- A
NonVisualTable
containing 10 items, subscribed to in MERGE mode, used
to get the events to write into the Flex TextArea.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_flex/examples/Flex4StockListDemo
|
|
|
|
This is the AIR version of the Flex Demo.
Installation instructions:
- Download and install Adobe AIR
(if not already installed).
- Click the "run the demo" button to download and install the application.
Tables involved:
- A
VisualTable
containing 10 items, subscribed to in MERGE mode, bound
to the Flex DataGrid.
- A
NonVisualTable
containing 10 items, subscribed to in MERGE mode, used
to get the events to write into the Flex TextArea.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_flex/examples/AIR4StockListDemo
|
|
|
|
This is a Flex version of the Portfolio Demo,
where a list of sent orders is kept and updated with the status of the request.
This app uses the Flex Client API for Lightstreamer to handle the communications with
Lightstreamer Server and uses the Flex DataGrid to display the real-time data.
The left table shows the automatic binding of a Lightstreamer data table configured to exploit
"two-level push" with a Flex widget (a DataGrid). You can sort on any columns and drag the columns around.
Using the form to the right, you can buy or sell a stock.
Clicking the "Random Orders" button, 20 random orders are placed in batch mode.
Orders are placed through the
LSClient.SendMessage
method.
The DataGrid, below the orders form, mantains a list of executed orders and their statuses
(PROCESSING, PROCESSED, ABORTED or ERROR).
Such statuses are received by the demo code by listening for
SendMessageAbortEvent,
SendMessageErrorEvent, and
SendMessageProcessedEvent events
and then placed in an ArrayCollection that is in turn bound to the DataGrid.
This portfolio is shared among all the connected users, so you can connect to this demo from different machines (or try at least different
browsers on the same machine), then submit orders from one browser and see the updates displayed on another browser. The same portfolio is
also shared among the various versions of the demo (Flex and HTML).
Tables involved:
- A
VisualTable
containing 1 item subscribed to in COMMAND mode. Each added row
automatically provokes an underlying subscription to a sub-item in MERGE
mode, to get the real-time price for that specific stock from another feed (the same as the
Stock-List Demos). When a row is deleted,
the underlying sub-item is automatically unsubscribed from.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_flex/examples/Flex4PortfolioDemo
|
|
|
|
|
This is a Silverlight version of the Stock-List Demos,
where thirty items are subscribed to.
This app uses the Silverlight Client API for Lightstreamer to handle the communications with
Lightstreamer Server and uses a Silverlight Grid to display the real-time data
pushed by Lightstreamer Server.
After launching the demo, the Silverlight application will automatically connect to
Lightstreamer Server and will subscribe to 30 stock quotes.
A Silverlight Grid is used to display the real-time data. You can sort on any columns and
drag the columns around (in this demo the resorting is not done automatically on each update).
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_silverlight/examples/SilverlightStockListDemo
|
|
|
|
|
This is a Java-for-Android version of the Stock-List Demos.
This app uses the Android Client API for Lightstreamer to handle the communications with
Lightstreamer Server. A simple user interface is implemented to display the real-time
data received from Lightstreamer Server.
To install the app from the Android Market, you can use the QR code to the left or visit
the corresponding Android Market page.
See the README.txt instructions contained the zip file with the source code (see below) to know more about
the application logic and to learn how to compile the code.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_android/examples/Android_StockListDemo
|
|
|
|
|
This app, compatible with both iPhone and iPad, is an Objective-C version of
the Stock-List Demos.
This app uses the iOS Client API for Lightstreamer to handle the communications with
Lightstreamer Server. A simple user interface is implemented to display the real-time
data received from Lightstreamer Server.
To install the app from the iTunes Store you can either go to the
iTunes Preview page
and choose "View In iTunes", or open iTunes and search for "Lightstreamer".
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_ios/examples/iOS_StockListDemo
|
|
|
|
|
This BlackBerry application contains two different screens: one with three stock quotes from the
Stock-List Demos, the other with four items from the
Round-Trip Demo.
This app uses the BlackBerry Client API for Lightstreamer to handle the communications with
Lightstreamer Server.
To install the application, click the "run the demo" button to download a ".jad" file to your phone.
As an alternative, point your mobile browser directly to the URL:
http://www.lightstreamer.com/demo/bb/lsbbdemo.jad
Once installed on your phone, run the application, give the requested rights, and
wait for the connection to be established (as shown in the top green bar).
If no connection can be established but your phone is connecting to the Internet properly
for other applications, it probably means that the access point list configured in the demo
is not compatible with your phone configuration. You might want to contact
support@lightstreamer.com for further information.
When the Basic Stock-List Demo is connected, you will see the yellow flashing cells of the Stock-List Demos.
Use the menu to switch to the other demo, where you can see the values of some
items of the Round-Trip Demo updated in real-time.
To publish new values, use the menu.
You can open the Round-Trip Demo on a PC browser and see the values
synchronized with the mobile phone.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_blackberry/examples/StockList_Interaction_BlackBerry
|
|
|
|
|
This is a Windows Phone version of the Stock-List Demos.
This app uses the Windows Phone Client API for Lightstreamer, based on Silverlight, to handle the communications with
Lightstreamer Server. A simple user interface is implemented to display the real-time
data received from Lightstreamer Server.
To install the app from the Windows Phone Marketplace, either click the "run the demo" button to the right
from your Windows Phone, or go to the Marketplace and search for "Lightstreamer".
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_windows_phone/examples/WindowsPhone_StockListDemo
|
|
|
|
|
This Java midlet contains two different screens: one with three stock quotes from the
Stock-List Demos, the other with four items from the
Round-Trip Demo.
This app uses the Java ME Client API for Lightstreamer to handle the communications with
Lightstreamer Server.
Click the "run the demo" button to download a MIDP 2.0 ".jad" file to your phone.
As an alternative, point your mobile browser to the URL, to choose between .jad and .jar:
http://www.lightstreamer.com/demo/midlet/
Once installed on your phone, run the midlet, allow the network connections, choose the access
point id prompted, and wait for the connection to be established (as shown in the top green bar).
You will see the yellow flashing cells of the Stock-List Demos.
Use the Option menu to switch to the other demo, where you can see the values of some
items of the Round-Trip Demo updated in real-time.
To publish new values, use the Option menu.
You can open the Round-Trip Demo on a PC browser and see the values
synchronized with the mobile phone.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_java_me/examples/StockList_Interaction_Midlet
|
|
|
|
|
This is a Java Swing version of the Stock-List Demos,
where thirty items are subscribed to.
This app uses the Java SE Client API for Lightstreamer to handle the communications with
Lightstreamer Server. A simple user interface is implemented to display the real-time
data received from Lightstreamer Server.
By clicking the "run the demo" button, a Java application will be downloaded and launched via
Java Web Start technology.
If Java Web Start is not already installed, you will be
automatically redirected to the download site.
When prompted, please accept the digital signature by www.lightstreamer.com.
You can sort on any columns and drag the columns around.
This application uses the "com.lightstreamer.ls_client" layer of the Lightstreamer
Java SE client library to connect to Lightstreamer Server and subscribe to the 30 items.
The application code implements auto-reconnection and auto-resubscription logic, together
with a connection status indicator.
Java Swing classes are used to display the real-time updates received from Lightstreamer
Server. The application code implements a cell highlighting mechanism too.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_java_se/examples/Swing_StockListDemo
|
|
|
|
|
This is a .NET version of the Stock-List Demos,
where thirty items are subscribed to.
This app uses the .NET Client API for Lightstreamer to handle the communications with
Lightstreamer Server. A simple user interface is implemented to display the real-time
data received from Lightstreamer Server.
Installation instructions:
- Click the "run the demo" button to download the application installer
(a ".msi" file).
- Execute the downloaded file to install the application (it is not digitally signed,
but we guarantee it does not contain any malicious code).
- Run the installed application.
The application uses a grid to display the real-time data. You can resize and drag the columns around.
To uninstall the application, go to the Windows Control Panel, choose the applet for managing
installed programs ("Add or Remove Programs" or something similar, depending on Windows' versions),
and select "Lightstreamer :: .NET Framework: Stock-List Demo".
Adapters involved:
Client source code (folder of Lightstreamer distribution - Allegro+, Presto, Vivace):
- DOCS-SDKs/sdk_client_dotnet/examples/DotNetClientStockListDemo
|
|
|
|
|
Dynamic Data Exchange (DDE) is
a technology for communication between multiple applications under Microsoft Windows,
often used for automatically filling a Microsoft Excel spreadsheet with data.
This Java application is basically a DDE bridge, which injects the real-time updates
received from Lightstreamer Server into an Excel spreadsheet. The quotes for 30 stock items are managed.
Installation instructions:
- Click the "run the demo" button. A Java application will be downloaded and launched via
Java Web Start technology. If Java Web Start
is not already installed, you will be automatically redirected to the download site.
- When prompted, please accept the digital signature by www.lightstreamer.com.
The application connects to Lightstreamer Server on one side
(by leveraging the Java SE Client API for Lightstreamer)
and delivers the received data to any DDE-enabled application that is running on the PC on the other
side (by leveraging a third-party DDE component for Java).
Launch the application, then click on "Start Lightstreamer" to connect to Lightstreamer Server
ans subscribe to the quotes. You will see the update count spinning in the lower margin.
Now click on "Copy Excel data to clipboard". The DDE subscription info will be copied into
the clipboard. Open an Excel speadsheet and paste the data (CTRL-V). The real-time updates will
show up on the spreadsheet.
To temporarily stop the DDE Server, without closing the Lightstreamer connection, click on
"Toggle data feeding to Excel".
Adapters involved:
Client source code (for Lightstreamer Allegro+, Presto, Vivace):
- download the zip file
|
|
|
|
Real-Time Data (RTD)
is a technology introduced in Microsoft Excel starting from 2002, aimed at replacing DDE for updating
spreadsheets in real time.
This demo is made up of a DLL library that acts as an RTD Server, which receives updates from
Lightstreamer Server on one side and injects them into Excel on the other side.
The library has been developed with C#.NET (full source code is provided, see below). It leverages the
.NET Client API for Lightstreamer to subscribe to 30 stock items and the Microsoft Office library
to set up the RTD server.
Installation instructions:
- You need Microsoft Excel 2002 or newer installed on your PC.
- Click the "run the demo" button to download the application installer (a ".msi" file).
- Execute the downloaded file to install the application.
- From the Start menu, go to the "Lightstreamer RTD Demo" folder, click the
"Start Lightstreamer Excel RTD Server Demo" link. This will open Excel and automatically load the "ExcelDemo.xls"
spreadsheet (which, by the way, is contained in
"C:\Program Files (x86)\Lightstreamer .NET RTD Server Demo library for Excel\static").
- The spreadsheet will activate the Lightstreamer RTD library, which will open a
control window, where you can see the data traffic.
The control windows shows a counter with the updates received from Lightstreamer Server
and logs such updates in real time. Is also shows the notifications issued towards Excel.
To pause the notification calls, uncheck "Data stream to Excel".
In the Excel spreadsheet, you will see several cells changing in real time. If the update rate
looks slow (that is, you don't see several updates in a second), it means that the
RTD ThrottleInterval of Excel is set to a high value. In order to activare real-time dispatching,
please follow these instructions:
- In Excel, go to the Visual Basic Editor (by pressing ALT+F11 or clicking Visual Basic
Editor from the Macro menu (Tools menu).
- Open the Immediate window (press CTRL+G or click Immediate Window on the View menu).
- In the Immediate window type this code and press ENTER:
Application.RTD.ThrottleInterval = 0
Adapters involved:
Client source code (for Lightstreamer Allegro+, Presto, Vivace):
- download the zip file
|
|
| |
|
| |
| |
|
|
|
|
