Real-Time Data Transmission using UDP

[Robert-Koifman]

UDP is widely used for real-time data transmission. Such data can include live audio/video or, for example, real-time digital samples of analog signals. The client application in this demo creates a UDP connection to the service application and sends 100 UDP packets at 200 milliseconds interval, with each packet containing a sequence number. The service application, in turn, prints a sequence number of each received packet. Because UDP is a non-guaranteed delivery protocol, depending on the quality of the network route, some of these packets may be lost. Which packets are lost can be determined by the missing numbers in the series of numbers printed by the service.

As usual, when explaining this example, I refer to the following guides:

1. Softnet Programming Model in Java / This guide explains the process of developing embedded apps using Softnet Endpoint Library (Java);
2. The Developer Guide to Softnet ASN.1 Codec (Java) / This guide explains how to use the Softnet ASN.1 codec in Java applications;
3. The User Guide to Softnet Management System / This guide explains how to use Softnet MS for managing devices and clients utilizing the Softnet platform. It is designed for both developers and users.

Before getting started

In order to run this example, you should have a Softnet MS account and be in the “Provider” role. For the purpose of learning Softnet Free we offer you a free registration on http://ts.softnet-iot.org/.

For setting up the endpoint library in your project, see “Setting up the endpoint library”.

The platform requires that outgoing connections to a specific set of TCP and UDP ports not be blocked. For details, see Requirements for the network infrastructure.

Creating the service application

Note! Before "The Application-specific Steps", the following material is identical to other service apps in Basic Examples, except that we set the Service Type to “UDP Demo” while the Contract Author is the same: “Softnet Guide”. The domain name is different, and the service account data, of course, is also different.

First, we go to the http://ts.softnet-iot.org/ and sign in to Softnet MS. Then, we create a new domain and name it “Real-Time Data Transmission using UDP”. This is how a newly created domain looks like:

Then, we create a new site in the domain. A newly created site has a status “site blank” and contains a blank service registration with status “service type undefined”:

Now open your favorite Java IDE and create a console application. Add a class named “ServiceApp” and insert the method main into the class. Then, import the following packages:

import softnet.*;
import softnet.service.*;
import softnet.exceptions.*;
import softnet.asn.*;

The softnet.service.ServiceEndpoint class of the platform provides the networking functionality for a service application. It has a static method to create an instance of the class:

public static ServiceEndpoint create(
   SiteStructure siteStructure,
   String version,
   ServiceURI serviceURI,
   String password) throws HostErrorSoftnetException

The first parameter of the method is an object that implements the SiteStructure interface. ServiceEndpoint has a static method to create the required object:

public static SiteStructure createStructure(
   String serviceType,
   String contractAuthor)

<serviceType> and <contractAuthor> are the minimum data required to create a SiteStructure object, so the method accepts these two mandatory parameters. Set the Service Type as “UDP Demo” and the Contract Author as “Softnet Guide”.

The second parameter of the create method is <version>. Assume the service’s API version is “1.0”. The method has two more parameters: <serviceUri> and <password>. Take their values on the site you have created in the beginning:

In my case, I had the following values for the <serviceUri> and <password>:

<serviceUri>:	softnet-srv://414e1fa2-5c35-4401-b985-9352678a269d@ts.softnet-iot.org
<password>:	w0KHdjgcrn

In real applications, this data can be stored in the application's config file.

At this point your code may look like the following:

import softnet.*;
import softnet.service.*;
import softnet.exceptions.*;
import softnet.asn.*;

public class ServiceApp
{
	static final String apiVersion = "1.0";
	
	public static void main(String[] args)
	{
		String service_uri = "softnet-srv://414e1fa2-5c35-4401-b985-9352678a269d@ts.softnet-iot.org";
		String password = "w0KHdjgcrn";

		ServiceEndpoint serviceEndpoint = null;
		try {							
			SiteStructure siteStructure = ServiceEndpoint.createStructure(					
				"UDP Demo",
				"Softnet Guide");
			
			ServiceURI serviceURI = new ServiceURI(service_uri);
			serviceEndpoint = ServiceEndpoint.create(siteStructure, apiVersion, serviceURI, password);			
		}		
		catch(java.lang.Throwable e) {
			e.printStackTrace();
		}
		finally {
			if(serviceEndpoint != null)
				serviceEndpoint.close(); // The service endpoint must be closed in the end!
			System.out.println("The app is closed!");
		}
	}
}

Do not forget to close the service endpoint in the end!

There is a set of the service's state parameters controlled by the platform that you might want to monitor. For each of these parameters, the platform generates an event when its value changes. To intercept these events, ServiceEndpoint has a listener method called addEventListener:

public void addEventListener(ServiceEventListener listener)

This method accepts an object that implements the ServiceEventListener interface with appropriate event handlers. Instead of implementing all the methods of ServiceEventListener, you can extend an abstract class ServiceEventAdapter which has empty implementations of these methods. In this case, you can just override the methods you need.

This example demonstrates monitoring the service status and the service connectivity status:

	serviceEndpoint.addEventListener(new ServiceEventAdapter()
	{
		@Override
		public void onConnectivityChanged(ServiceEndpointEvent e)
		{
			ServiceEndpoint serviceEndpoint = e.getEndpoint();
			EndpointConnectivity connectivity = serviceEndpoint.getConnectivity();
			System.out.println(String.format("Service connectivity status: %s, Error: %s, Message: %s", connectivity.status, connectivity.error, connectivity.message));
		}

		@Override
		public void onStatusChanged(ServiceEndpointEvent e)
		{
			ServiceEndpoint serviceEndpoint = e.getEndpoint();
			System.out.println(String.format("Service status: %s", serviceEndpoint.getStatus()));							
		}		
	});

The first method, onConnectivityChanged, is called whenever the service’s connectivity changes. It reflects the status of a physical connection with the Softnet server and the result of authentication. After the connection is established, Softnet examines the status of the service and calls the listener’s method onStatusChanged. If your service’s status is <Online>, it is ready to serve clients.

The Application-specific Steps

Here we have reached the point where we can implement accepting a UDP connection and receiving packets from the UDP socket. Note that a UDP connection should be thought of as a route between two endpoints to transmit packets over the Internet, rather than a classic handshaking connection like TCP. How to work with UDP in service applications is described in "Handling UDP connection requests". The service endpoint accepts UDP connection requests on a virtual port, which is not associated with any permanent physical port. The service application first creates a binding to a virtual port, then accepts incoming requests as computing resources become available.

To create a virtual port binding, ServiceEndpoint has three udpListen method overloads that differ in the way they define access rules. For simplicity, we use one that does not impose any access restrictions:

public void udpListen(int virtualPort, int backlog)

The first parameter is a virtual port. We set it to 17. The second parameter, <backlog>, plays the same role as in classical sockets. See in the "Handling UDP connection requests" for details. We set its value to 2.

serviceEndpoint.udpListen(17, 2);

To accept the established connections, ServiceEndpoint has a method udpAccept:

public void udpAccept(int virtualPort, UDPAcceptHandler acceptHandler)

The first parameter, <virtualPort>, must have the same value as you specified for the udpListen. In our case, this is 17. The second parameter takes an implementation of the UDPAcceptHandler interface. The udpAccept method is called whenever the application is ready to handle the next established UDP connection. If you want to have only one accepted connection at a time, you can implement the next call to udpAccept just after closing the socket currently receiving data. In our case, we do this before leaving the accept method of MyUDPAcceptHandler:

import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetSocketAddress;
import java.net.SocketTimeoutException;
import java.io.IOException;

import softnet.*;
import softnet.exceptions.*;
import softnet.service.*;
import softnet.asn.*;

class MyUDPAcceptHandler implements UDPAcceptHandler
{
	public void accept(RequestContext context, DatagramSocket datagramSocket, InetSocketAddress remoteSocketAddress, ConnectionMode mode) {
		System.out.println(String.format("The UDP connection established in '%s' mode", mode));
		
		try {			
			byte[] buffer = new byte[15];  
			DatagramPacket packet = new DatagramPacket(buffer, 15);  

			datagramSocket.setSoTimeout(5000);
			int rawNumber = 0;
			System.out.println("Sequence numbers of received packets:");
			for(int i=0; i<100; i++) {
				packet.setLength(15);
				datagramSocket.receive(packet);  				
				SequenceDecoder asnInput = ASNDecoder.Sequence(packet.getData());
				int number = asnInput.Int32();
				if(number / 10 != rawNumber) {
					rawNumber = number / 10;
					System.out.println();
				}
				System.out.print(String.format("%d,\t", number));
			}
			System.out.println();
		}
		catch(SocketTimeoutException e) {
			System.out.println();
		 }
		catch(IOException e) {
			System.out.println(String.format("UDP socket error: %s", e.getMessage()));
		}
		catch(AsnException e) {
			System.out.println(String.format("Input data format error: %s", e.getMessage()));
		}	
		finally {
			datagramSocket.close();
			context.serviceEndpoint.udpAccept(17, new MyUDPAcceptHandler());
		}
	}
}

accept is the only method of UDPAcceptHandler to implement. Its first parameter of type RequestContext has a serviceEndpoint field which is the service endpoint we created earlier. After receiving the set of UDP packets and closing the socket, we use this field to call udpAccept again. This is not a recursive call because udpAccept is a method called asynchronously. The second parameter, <datagramSocket>, of the accept method is a UDP socket for an established connection. The third parameter, <remoteSocketAddress>, is an IP address and port of the remote endpoint with which the connection is established. And the fourth parameter indicates the connection mode: peer-to-peer or proxy. We use the ASN.1 DER codec to encode/decode the UDP packet sequence numbers. The Developer Guide to Softnet ASN.1 Codec (Java) explains how to use this codec in Java applications.

Now we just need to add the last lines of code to the main method:

serviceEndpoint.udpListen(17, 2);			
serviceEndpoint.udpAccept(17, new MyUDPAcceptHandler());
			
serviceEndpoint.connect();
System.in.read(); // waits until pressing the Enter key

Let's put everything together and compose the entire application:

import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetSocketAddress;
import java.net.SocketTimeoutException;
import java.io.IOException;

import softnet.*;
import softnet.exceptions.*;
import softnet.service.*;
import softnet.asn.*;

class MyUDPAcceptHandler implements UDPAcceptHandler
{
	public void accept(RequestContext context, DatagramSocket datagramSocket, InetSocketAddress remoteSocketAddress, ConnectionMode mode) {
		System.out.println(String.format("The UDP connection established in '%s' mode", mode));
		
		try {			
			byte[] buffer = new byte[15];  
			DatagramPacket packet = new DatagramPacket(buffer, 15);  
		    
			datagramSocket.setSoTimeout(5000);
			int rawNumber = 0;
			System.out.println("Sequence numbers of received packets:");
			for(int i=0; i<100; i++) {
				packet.setLength(15);
				datagramSocket.receive(packet);  				
				SequenceDecoder asnInput = ASNDecoder.Sequence(packet.getData());
				int number = asnInput.Int32();
				if(number / 10 != rawNumber) {
					rawNumber = number / 10;
					System.out.println();
				}
				System.out.print(String.format("%d,\t", number));			
			}
			System.out.println();
		}
		catch(SocketTimeoutException e) {
			System.out.println();
		 }
		catch(IOException e) {
			System.out.println(String.format("UDP socket error: %s", e.getMessage()));
		}
		catch(AsnException e) {
			System.out.println(String.format("Input data format error: %s", e.getMessage()));
		}	
		finally {
			datagramSocket.close();
			context.serviceEndpoint.udpAccept(17, new MyUDPAcceptHandler());
		}
	}
}

public class ServiceApp {

	static final String apiVersion = "1.0";

	public static void main(String[] args) {
		String service_uri = "softnet-srv://414e1fa2-5c35-4401-b985-9352678a269d@ts.softnet-iot.org";
		String password = "w0KHdjgcrn";
		
		ServiceEndpoint serviceEndpoint = null;
		try	
		{							
			SiteStructure siteStructure = ServiceEndpoint.createStructure(					
				"UDP Demo",
				"Softnet Guide");
			
			ServiceURI serviceURI = new ServiceURI(service_uri);
			serviceEndpoint = ServiceEndpoint.create(siteStructure, apiVersion, serviceURI, password);			
			
			serviceEndpoint.addEventListener(new ServiceEventAdapter() {
				@Override
				public void onConnectivityChanged(ServiceEndpointEvent e) {
					ServiceEndpoint serviceEndpoint = e.getEndpoint();
					EndpointConnectivity connectivity = serviceEndpoint.getConnectivity();
					System.out.println(String.format("Service connectivity status: %s, Error: %s, Message: %s", connectivity.status, connectivity.error, connectivity.message));
				}

				@Override
				public void onStatusChanged(ServiceEndpointEvent e) {
					ServiceEndpoint serviceEndpoint = e.getEndpoint();
					System.out.println(String.format("Service status: %s", serviceEndpoint.getStatus()));							
				}		
			});

			serviceEndpoint.udpListen(17, 2);
			serviceEndpoint.udpAccept(17, new MyUDPAcceptHandler());
			
			serviceEndpoint.connect();
			System.in.read(); // waits until pressing the Enter key
		}		
		catch(java.lang.Throwable e) {
			e.printStackTrace();
		}
		finally {
			if(serviceEndpoint != null)
				serviceEndpoint.close();
			System.out.println("The app is closed!");
		}
	}
}

Now we need to run the application so that the platform constructs the site and we could create the client entity. If the service endpoint establishes connection with the Softnet server, you application will print out something like this:

Service connectivity status: AttemptToConnect, Error: NoError, Message: null
Service connectivity status: Connected, Error: NoError, Message: null
Service connectivity status: Disconnected, Error: RestartDemanded, Message: The softnet server demanded to restart the endpoint.
Service connectivity status: AttemptToConnect, Error: NoError, Message: null
Service connectivity status: Connected, Error: NoError, Message: null
Service status: Online

The meaning of these messages is as follows: on the first connection of the service endpoint, the server constructs the site, and then the server demands the service endpoint to re-establish the connection. When connecting to the server for the second time, the service is assigned the Online status.

The site, which was originally blank, will be constructed in accordance with the "siteStructure" object attached to the "serviceEndpoint". In case of our example, it has the following view:

The platform adds the Owner user to the site by default. Now we can create clients associated with this user.

Creating the client application

Now we'll develop a client. In your favorite Java IDE create a console application.

Note! Before "The Application-specific Steps", the following material is identical to other client apps in Basic Examples, except that in the client endpoint creation we set the Service Type and Contract Author to “UDP Demo” and “Softnet Guide”, accordingly. The client account data, of course, is also different.

Add a class named “ClientApp” and insert the main method into the class. Then, import the following packages:

import softnet.*;
import softnet.client.*;
import softnet.exceptions.*;
import softnet.asn.*;

The softnet.client.ClientSEndpoint class provides the networking functionality for a client application to communicate with a single remote service. It has a static method to create an instance of the class, i.e. a client endpoint:

public static ClientSEndpoint create(
	String serviceType,
	String contractAuthor,
	ClientURI clientURI, 
	String password, 
	String clientDescription)

We set the first two parameters, <serviceType> and <contractAuthor>, as “UDP Demo” and “Softnet Guide”. This ensures that the client will be able to communicate only with a service which Service Type and Contract Author are the same. The third parameter is <clientURI>. We get it from the account section of the client registration. But, first, we have to create the client registration on the site. Let's open the example’s domain we have created in the beginning. Then we open the site in which we’ve registered the service. Clicking the clients button opens the client management section of the site:

Clicking the add client button to the right of the Owner creates an empty client registration:

Clicking the generate password button generates the password:

In my case, I had the following values for the <clientURI> and <password>:

<clientURI>:	softnet-s://p95h2uk1@ts.softnet-iot.org
<password>:	eA6ek7mBeS

In real applications, this data can be stored in the application's config file.

Now, we have all the required data. The following code shows how the client endpoint creation code may look like:

import softnet.*;
import softnet.asn.*;
import softnet.exceptions.*;
import softnet.client.*;

class ClientApp
{	
	public static void main(String[] args)
	{
		String client_uri = "softnet-s://p95h2uk1@ts.softnet-iot.org";
		String password = "eA6ek7mBeS";
		
		ClientSEndpoint clientSEndpoint = null;
		try {
			ClientURI clientURI = new ClientURI(client_uri);
	
			clientSEndpoint = ClientSEndpoint.create(
				"UDP Demo", 
				"Softnet Guide",
				clientURI, 
				password,
				"UDP Demo Client");
		}
		catch(java.lang.Throwable e)	{
			e.printStackTrace();
		}
		finally {
			if(clientSEndpoint != null)
				clientSEndpoint.close();
			System.out.println("The app is closed!");
		}
	}

As with the service application, we want to monitor the client status and the client connectivity status. To intercept the platform events related to clients, ClientSEndpoint has a method addEventListener:

public void addEventListener(ClientEventListener listener)

This method accepts an object that implements the ClientEventListener interface with appropriate event handlers. As with the service application, instead of implementing all the ClientEventListener methods, you can extend an abstract class ClientEventAdapter which has empty implementations of these methods. This allows you just to override the methods you want to implement.

Along with two events related to the status parameters described above, we need to intercept the ServiceOnline event, which notifies the client when the remote service goes online. To do so, we'll override the onServiceOnline handler of ClientEventAdapter. The code snapshot for the event handlers might look like this:

	clientSEndpoint.addEventListener(new ClientEventAdapter()
	{
		@Override
		public void onConnectivityChanged(ClientEndpointEvent e) {
			ClientEndpoint client = e.getEndpoint();
			EndpointConnectivity connectivity = client.getConnectivity();
			System.out.println(String.format("Client connectivity status: %s, Error: %s, Message: %s", connectivity.status, connectivity.error, connectivity.message));
		}

		@Override
		public void onStatusChanged(ClientEndpointEvent e) {
			ClientEndpoint client = e.getEndpoint();
			System.out.println(String.format("Client status: %s", client.getStatus()));					
		}
				
		@Override
		public void onServiceOnline(RemoteServiceEvent e)  {
			System.out.println(String.format("Remote service online! Hostname: %s, Service version: %s", e.service.getHostname(), e.service.getVersion()));					
		}		
	});

The way onServiceOnline works requires some explanation. Before making an TCP connection request to a remote service, your client app must be able to check its own online status and the online status of the remote service. If one or both of them are offline, the client should wait until the communication platform notifies that both are online. The onServiceOnline method serves this purpose. The platform calls it in one of the following two cases:

1. The remote service corresponding to “e.service” gets online while the client has already been online;
2. The client gets online while the remote service has already been online. But this is only true for a single-service client, as in our case. If the client is a multi-service client, then a different approach is used. See the «Interface ClientEventListener» section for more details.

It follows that in the case of our single-service client, if the onServiceOnline method is called, both the client and the service are online, and the client can make a request.

The Application-specific Steps

Let's write the code for establishing a UDP connection to virtual port 17, which the service app is listening on. ClientSEndpoint has a method udpConnect for this:

public void udpConnect(int virtualPort, UDPResponseHandler responseHandler)

The second overload of this method has an extra parameter <requestParams> of type RequestParams, that allows the caller to specify such data as an attachment for the response handler, a request timeout, and a session tag for the remote request handler.

Note that ClientSEndpoint is a class derived from ClientEndpoint, which is a multi-service endpoint class. ClientEndpoint also has two overloaded methods udpConnect similar to those of ClientSEndpoint, but these methods each has an additional parameter RemoteService used to specify the target remote service. See «Making UDP connection requests» for details.

So, for the first parameter of udpConnect we specify 17. The second parameter takes an implementation of UDPResponseHandler. Let's take a look at this interface:

public interface UDPResponseHandler {
	void onSuccess(
		ResponseContext context,
		java.net.DatagramSocket datagramSocket,
		java.net.InetSocketAddress remoteSocketAddress,
		ConnectionMode mode);
	void onError(ResponseContext context, SoftnetException exception);
}

The interface has two methods to implement. Each request ends with a callback to one of these methods. In case of success, the onSuccess method is called back. Its first parameter, <context>, is provided by the platform. Any response handler has this type of parameter. It is described in Making UDP connection requests. The second parameter, <datagramSocket>, of the onSuccess method is a UDP socket for an established connection. The third parameter, <remoteSocketAddress>, is an IP address and port of the remote endpoint with which the connection is established. And the fourth parameter indicates the connection mode: peer-to-peer or proxy.

The onError method is called back when an error is detected by the platform. It provides the error in the second parameter of type SoftnetException. The possible exceptions are described in Making UDP connection requests.

We can implement the UDPResponseHandler by anonymous class. Then, it might look like the following:

import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetSocketAddress;
import java.io.IOException;

import softnet.*;
import softnet.exceptions.*;
import softnet.client.*;
import softnet.asn.*;

clientSEndpoint.udpConnect(17, new UDPResponseHandler() 
{
	public void onSuccess(ResponseContext context, DatagramSocket datagramSocket, InetSocketAddress remoteSocketAddress, ConnectionMode mode)
	{
		System.out.println(String.format("The UDP connection established in '%s' mode", mode));

		try {								
			System.out.println("Sequence numbers of sent packets:");
			for(int i=0; i<100; i++) {
				ASNEncoder asnEncoder = new ASNEncoder();
				asnEncoder.Sequence().Int32(i);
				byte[] buffer = asnEncoder.getEncoding();
				DatagramPacket packet = new DatagramPacket(buffer, buffer.length, remoteSocketAddress);
				datagramSocket.send(packet);  				
				System.out.print(String.format("%d, ", i));
				Thread.sleep(200);
			}
			System.out.println();
		}
		catch(IOException e) {
			System.out.println(String.format("UDP socket error: %s", e.getMessage()));
		}
		catch(InterruptedException e) { }
		finally {
			datagramSocket.close();
		}
	}

	public void onError(ResponseContext context, SoftnetException exception) {
		System.out.println(String.format("The UDP connection request failed with an error: %s", exception.getMessage()));	
	}						
});

We can place the code for calling the udpConnect and the code for sending UDP packets in the body of onServiceOnline. Now, let's put everything together. The following is the entire code of the application:

import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetSocketAddress;
import java.io.IOException;

import softnet.*;
import softnet.exceptions.*;
import softnet.client.*;
import softnet.asn.*;

public class ClientApp 
{
	public static void main(String[] args)
	{
		String client_uri = "softnet-s://p95h2uk1@ts.softnet-iot.org";
		String password = "eA6ek7mBeS";
		
		ClientSEndpoint clientSEndpoint = null;
		try
		{
			ClientURI clientURI = new ClientURI(client_uri);
	
			clientSEndpoint = ClientSEndpoint.create(
				"UDP Demo", 
				"Softnet Guide",
				clientURI, 
				password,
				"UDP Demo Client");
			
			clientSEndpoint.addEventListener(new ClientEventAdapter()
			{
				@Override
				public void onConnectivityChanged(ClientEndpointEvent e) {
					ClientEndpoint client = e.getEndpoint();
					EndpointConnectivity connectivity = client.getConnectivity();
					System.out.println(String.format("Client connectivity status: %s, Error: %s, Message: %s", connectivity.status, connectivity.error, connectivity.message));
				}

				@Override
				public void onStatusChanged(ClientEndpointEvent e) {
					ClientSEndpoint client = (ClientSEndpoint)e.getEndpoint();
					System.out.println(String.format("Client status: %s", client.getStatus()));					
				}
				
				@Override
				public void onServiceOnline(RemoteServiceEvent e) {
					System.out.println(String.format("Remote service online! Hostname: %s, Service version: %s", e.service.getHostname(), e.service.getVersion()));	
				
					ClientSEndpoint clientSEndpoint = (ClientSEndpoint)e.getEndpoint();

					clientSEndpoint.udpConnect(17, new UDPResponseHandler() 
					{
						public void onSuccess(ResponseContext context, DatagramSocket datagramSocket, InetSocketAddress remoteSocketAddress, ConnectionMode mode) 
						{
							System.out.println(String.format("The UDP connection established in '%s' mode", mode));

							try {								
								System.out.println("Sequence numbers of sent packets:");
								for(int i=0; i<100; i++) {
									ASNEncoder asnEncoder = new ASNEncoder();
									asnEncoder.Sequence().Int32(i);
									byte[] buffer = asnEncoder.getEncoding();
									DatagramPacket packet = new DatagramPacket(buffer, buffer.length, remoteSocketAddress);
									datagramSocket.send(packet);  				
									System.out.print(String.format("%d, ", i));
									Thread.sleep(200);
								}
								System.out.println();
							}
							catch(IOException e) {
								System.out.println(String.format("UDP socket error: %s", e.getMessage()));
							}
							catch(InterruptedException e) { }
							finally {
								datagramSocket.close();
							}
						}

						public void onError(ResponseContext context, SoftnetException exception) {
							System.out.println(String.format("The UDP connection request failed with an error: %s", exception.getMessage()));	
						}
						
					});
				}		
			});
			
			clientSEndpoint.connect();
			System.in.read(); // waits until pressing the Enter key
		}
		catch(java.lang.Throwable e) {
			e.printStackTrace();
		}
		finally {
			if(clientSEndpoint != null)
				clientSEndpoint.close();
			System.out.println("The app is closed!");
		}
	}
}

Running the example

First we run the client applications. If everything is ok, you will see the following output:

Client connectivity status: AttemptToConnect, Error: NoError, Message: null
Client connectivity status: Connected, Error: NoError, Message: null
Client status: Online

From this output we can see that the client has connected to the server and it is assigned the Online status. Since the service is still offline, the onServiceOnline handler has not yet been called by the platform.

Now we run the service application, and If everything is ok, you will see the following output:

Service connectivity status: AttemptToConnect, Error: NoError, Message: null
Service connectivity status: Connected, Error: NoError, Message: null
Service status: Online

As the service came online, the platform raises ServiceOnline event in the client app, which is caught by the onServiceOnline handler. The handler prints the message provided below and calls the udpConnect method.

Remote service online! Hostname: Service1, Service version: 1.0

If the connection is successfully established, the client prints the following message, with the only difference that the connection mode can be 'P2P' or 'Proxy':

The UDP connection established in 'P2P' mode

Right at the same time, the identical message prints the service app too with the same connection mode as printed the client:

The UDP connection established in 'P2P' mode

Then the client starts sending UDP packets, each containing a sequence number encoded in the ASN.1 format. When sending the packets, it prints their sequence numbers:

Sequence numbers of sent packets:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,

On the other side, the service app prints the sequence numbers of the received packets:

Sequence numbers of received packets:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,