 |
|
|
Demo Selection
|
Below is a selection of the
available online Lightstreamer demos.
Visit the full demo gallery.
|
|
Full List of Demos
|
Below is the full list of online demos. 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.).
HTML & JAVASCRIPT
OTHER AJAX FRAMEWORKS
FLASH - FLEX - AIR
SILVERLIGHT
.NET
JAVA SE
JAVA ME
OTHERS
|
|
|
Below is the detailed information on each demo.
|
|
HTML
&
JAVASCRIPT
|
|
|
This demo displays real-time market data for ten stocks, generated by a feed
simulator. 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
|
|
OTHER
AJAX
FRAMEWORKS
|
|
|
A demonstration of simple integration between Lightstreamer and
TIBCO General Interface.
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.
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 Dojo 0.4.3.
The demo uses the Dojo widget FilteringTable and the Dojo charting
system to display the events generated by the Lightstreamer Server in both textual and graphical
forms.
Click on the Name column header to resort the stocks in the table.
Use the check boxes to add and remove stock from the chart.
Note: Dojo 0.4.3 charting system has known issues on Firefox 3.
A detailed explanation
of this application is available.
Tables involved:
Adapters involved:
Client source code:
- download the zip file
|
|
|
|
An integration demo of Lightstreamer and Microsoft ASP.NET AJAX.
An ASP.NET AJAX ReorderList is used 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
|
|
|
|
An integration demo of Lightstreamer and JQuery Grid Plugin.
The demo uses jqGrid to display the real-time data pushed by the 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
|
|
|
|
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 Web client 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
|
|
FLASH
FLEX
AIR
|
|
|
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 movie uses the ActionScript/JavaScript Bridge provided as part of the
"sdk_client_flash_flex(js_bridge)". That means the ActionScript API, used within the Flash
application, talk to external JavaScript API, that in turn use the Lightstreamer Web Client
API to communicate 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_flex(js_bridge)/examples/FlashBasic
|
|
|
|
This is a Flash version of the Stock-List Demos,
which displays eight stock quotes with some nice graphic effects.
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_flex(js_bridge)/examples/FlashStockList
|
|
|
|
This is a Flex version of the Stock-List Demos,
where ten items are subscribed to.
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 - Presto & Vivace only):
- Flex 3: DOCS-SDKs/sdk_client_flash_flex(native_as)/examples/FlexStockListDemo
- Flex 4: DOCS-SDKs/sdk_client_flash_flex(native_as)/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 - Presto & Vivace only):
- Flex 3: DOCS-SDKs/sdk_client_flash_flex(native_as)/examples/AIRStockListDemo
- Flex 4: DOCS-SDKs/sdk_client_flash_flex(native_as)/examples/AIR4StockListDemo
|
|
SILVERLIGHT
|
|
|
This is a Silverlight version of the Stock-List Demos,
where thirty items are subscribed to.
After launching the demo, wait for the "Lightstreamer is pushing..." message to appear,
then click the "Subscribe" button to start the data push.
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 - Presto & Vivace only):
- DOCS-SDKs/sdk_client_silverlight/examples/SilverlightStockListDemo
|
|
.NET
|
|
|
This is a .NET version of the Stock-List Demos,
where thirty items are subscribed to.
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 "Windows Control Panel" -> "Add or Remove Programs" and
select "Lightstreamer .NET Client Demo".
Adapters involved:
Client source code (folder of Lightstreamer distribution - Presto & Vivace only):
- DOCS-SDKs/sdk_client_dotnet/examples/DotNetClientStockListDemo
|
|
JAVA SE
|
|
|
This is a Java Swing version of the Stock-List Demos,
where thirty items are subscribed to.
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:
- download the zip file
|
|
JAVA ME
|
|
|
This Java midlet contains two different screens: one with three stock quotes from the
Stock-List Demos, the other with four items fro the
Round-Trip Demo.
Installation instructions:
- Click the "run the demo" button to download a MIDP 2.0 ".jad" file to your phone.
- As an alternative, a MIDP 1.0 version is available too (for very old phones). Altogether, four
different download links are available: JAD for MIDP 2.0; JAR for MIDP 2.0; JAD for
MIDP 1.0; JAD for MIDP 1.0. The JAD for MIDP 2.0 should work on most phones.
To get the four links above easily on your phone, simply visit this url with your
mobile browser:
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 updates in real-time.
To publish new values, use the Option menu.
You can open the web Round-Trip Demo on a PC and see the values
synchronized with the mobile phone.
Adapters involved:
Client source code (folder of Lightstreamer distribution - Presto & Vivace only):
- DOCS-SDKs/sdk_client_java_me/examples/StockList_Interaction_Midlet
|
|
OTHERS
|
|
|
This application is a DDE bridge that injects into an Excel spreadsheet the real-time updates
received from Lightstreamer Server. The quotes for 30 stock items are managed.
quotes from Lightstreamer Server.
By clicking the "run the demo" button a Java application will be downloaded and launched through the
Java Web Start technology. If Java Web Start is not already installed, you will be
automatically redirected to the download site.
The application is a DDE Server implemented in Java. It connects to Lightstreamer Server on one side
and delivers the received data to any DDE-enabled application that is running on the PC on the other
side.
Launch the application, then click on the button that will apper in the DDE Server window.
The subscription info will be copied into the clipboard. Paste the info into an Excel sheet
and enjoy the real-time updates pushde to spreadsheet.
Adapters involved:
Client source code:
- N/A
|
|
|
|
iStreamLight is an open-source Cocoa library that implements the Lightstreamer
network protocol. By incorporating this library in an iPhone application, it is
possible to develop a native Lightstreamer client for the iPhone quite easily.
The "run the demo" button launches a YouTube video that shows a demo application based on
iStreamLight in action. Such demo is publicly available from the repository of the
iStreamLight project on Google Code.
Adapters involved:
Client source code:
- See iStreamLight
|
|
| |
|
| |
| |
|
|
|
|
