The aspects of optimizing route parameters and creating a supply chain using artificial intelligence have been presented in our blog posts recently. In one of our recent posts, we presented how AI route optimization may be used not only for the logistics industry but also for pharmacy medicine transport coordination for corporate pharmacy networks. Another application that we developed recently for one of our corporate clients is a support decision system for emergency actions aimed at improving the operational effectiveness of local rescue operations. 

In this post, we described how we utilized DeliverM8 logistics optimization platform, as support of entities in emergency situations. We will briefly present how modern IT technologies such as mobile apps, push notifications and web applications can bring observable benefits and even improve security and effectiveness of operations, which is crucial in emergency situations.

Use Case

The use case described in this article is a system supporting local fire brigade teams in real-time navigation and communication during actions which is archived by providing team members with the current traffic, roadblock and general current situational awareness regarding the route availability and supporting real-time decisions in the scope of route selection.

The implemented system must meet the following requirements:

• enable entering the address of the incident,
• generate three alternative routes to the selected incident destination,
• inform the fire brigade via push notifications, text messages or other options…
• transmit the route seamlessly to a built-in navigation device (Android),
• display the route and the locations of emergency infrastructure (nearest hydrants, evacuation points etc)  around the incident, allowing the selection of the target destination,
• navigation to the selected destination via the built-in navigation system.

To meet these requirements, we have built a three-layer architecture, where the database is located on a central server, and access to it is possible through the data management and processing module. Operating server provides functionalities available via REST API for a user interface dedicated for web browsers and mobile applications. The communication structure between the individual components is shown in the figure below.

The target application was implemented using Java Spring with the PostgreSQL, while the web and Android application was provided by the Angular framework.

An example of using the system

One of the most important for the end-user to work with the proposed system is appropriate handling of real-time passability of chosen routes and passes. Therefore, we proposed a solution where our system communicates via dedicated interfaces with an internal infrastructure of our clients and verifies passability of the chosen route. In the case of road-block, the system is capable of choosing different routes that pass it to the navigation device seamlessly. Generating routes works on the basis of an iterative process and successive avoidance of waypoints, which in this case are railway crossings. Having the visualization and the necessary parameters, the user may choose the best alternative at a given moment.

In order to illustrate how the system works, the generated solution is shown in the figure below.

Additionally, by clicking on the “Plan” section as in the figure above, the user may analyze a route data such as railroad crossings, distance in kilometres and ETA (estimated time of arrival). The next step is to select the route by clicking on the map and uploading it to the navigation application for the emergency brigade. Thanks to this, the system informs a built-in navigation subsystem tablet about the event from the backend side, e.g. via a push or SMS notification.

 

After approving this notification, the system displays a map component with the destination route and the information required to perform emergency action such as locations of hydrants in the vicinity of the event location. Clicking on the target allows the user to navigate via using built-in navigation functionality button. We showed it in GIF animations below. 

 

Summary

In this short use-case blog, we presented how our logistic transport optimization platform helps to support real-time emergency actions performance. An example of using a fully connected system for a standard user takes about a minute from pointing a target to send navigation data to a mobile tablet. There is a significant time difference compared to the previous execution of all activities. In addition, the desired route is selected based on the decision block and the input information analyzed in real-time. Moreover, the system provides specialized tools tailored to the client’s needs., namely the archiving and reporting on previous incidents and their visualization and analysis in a dedicated responsive user interface.

Planning tasks in Java

In the last post by my teammate we presented how to manage back-end long-running asynchronous tasks from the client side. This approach is used especially in handling the appropriate flow of processes and the timely implementation of specific IT system services that require significant amount of computations. From the backend implementation perspective, one of the libraries that enable task scheduling and easy integration with Java Spring applications is Quartz. In the following sections of the article, the general problem of running background tasks and a use case presenting an example solution will be described.

Description of the problem

In some cases, the specification of an IT system requires long-running tasks to be performed in background. Compared to synchronous jobs where we wait for output, background jobs allow us to move on to the next job before our primary task is finished. This can be achieved by executing independent tasks in separate threads, which inform the main thread of the application when particular background job is completed. In this case, one thread can be a code block or a method that is a separate unit of work.

The advantages of asynchronous job scheduling tasks include:

• application performance,
• responsiveness and scalability,
• the ability to update the progress or parameters of the task,
• productive planning of service delivery,
• the ability to perform the following tasks without freezing the application state.

However, when running background, it is important to remember to skillfully choose between asynchronous and synchronous programming. If You are dealing with simple, short-lived calculations, it is not a good idea to use background tasks. For instance, too many asynchronous calls between main thread and background can make your code less readable, may cause slow application performance or even lead to thread lock and interrupt application lifecycle.

Check out how we deal with such problems in our team.

Use case, solution

In this post, as an example of using asynchronous programming, we will use a big data download service. Let us assume that a potential user of our website would like to transfer a certain number of files using logic provided by our backend application. As it is presented in the diagram below, the user interface allows to execute task that starts to transfer the file via request made to application server. Since we expect that this task will be a long running one, our goal is to schedule this job to be performed in background thread. Let’s have a look at details:

 

In applications based on Spring, the aforementioned Quartz library is the perfect choice. It allows you to schedule tasks depending on our needs.

Let’s make the following assumptions:

• the user can order to download several files at a time,
• in this case, the tasks will be performed sequentially,
• the user can  (interrupt) tasks,
• user is provided with information about tasks, such as id or user data, in the database.

Note that with the use of Quartz, you can execute threads simultaneously, but for the purpose of this post will used the task queue. The key interfaces used in this API are Scheduler, Job, JobDetail, JobDataMap, Trigger.

Initially, you need to create a Scheduler instance as the main interaction component. This can be done by injection into a class or by using the lines of code below.

SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();

The next step is to define an example class, in this case FileDownloadJob, extended by the QuartzJobBean class, which implements the Job interface. The main method executeInternal(),  will be called by one of the Scheduler threads after the Trigger is fired. Inside it, the target action of a given task should be performed.

public class FileDownloadJob extends QuartzJobBean {

   @Override
   protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionExceptions{
       // target code of performed operations
   }
}

The job scheduling process consists of assigning a unique key “JobKey”, preparing a JobDataMap and building a JobDetail instance. Assuming the “task” object is one of the records in the task database repository, the operations in question can be performed with the following lines of code.

JobKey jobKey = JobKey.jobKey((task.getId());

JobDataMap jobData = new JobDataMap();
jobData.putAll(new HashMap<>() {{
 	  put("email", user.getEmail());
  	  put("name", user.getName());
          put("progress", task.getProgress());
}});

JobDetail jobDetail = newJob().ofType(FileDownloadJob.class)
       				.withIdentity(jobKey)
      				.setJobData(jobData)
      				.build();

If we have all the details, we can fire the trigger and plan our task.

Trigger trigger = newTrigger()
       .startNow()
       .build();

scheduler.scheduleJob(jobDetail, trigger);

Returning to the assumptions of the solution, consider the possibility of deleting tasks. In the Quartz library it is possible to additionally implement the InterruptableJob interface in our job class.

public class FileDownloadJob extends QuartzJobBean implements InterruptableJob

It implements the interrupt() method where we can stop the job.

@Override
public void interrupt() {
   _interrupted = true;
}

Assuming that the operations performed inside the job are carried out in a loop, we can check the given _interrupted field, and for example if it is equal to True, terminate the job.

if (_interrupted) {
   break;
}

Of course, this is just an example of a job interruption. It is fully dependent on the operations performed within the method of execution. From the Scheduler side, the method shown below allows us to call the interrupt() method inside our FileDownloadJob class.

scheduler.interrupt(jobKey);

Another functionality is the sequential execution of tasks. This can be implemented in various ways, such as JobListener or smart use of JobDataMap. In our use case, we choose the second option, due to the possibility of further expansion, i.e. updating progress, stopping and resuming tasks.
Let’s add another field in our map and fill it with the id of the next job, assuming that all information about the tasks is stored in the database.

jobDataMap.put("nextJob", nextTask.getId());

Thanks to this, when we finish the operation of the first job, we can check if there is a unique key in the “nextJob” field of JobDataMap. If so, we move on to the next task. If we would like to add the functionality of changing the order of task execution, we could define another “previousTask” field storing the id of the previous task. Based on this, we could define appropriate methods to modify the queue position. In addition, in our map we can store the previously mentioned information about the current data download process and update it via REST endpoints in the client interface.

Java Scheduling – Summary

Asynchronous programming is an essential element in delivering some IT system services. However, it should be remembered that the use of background tasks should be carefully selected for the problem in order to avoid unnecessary conflicts or system overload. If you are using Java, the Quartz library is a good choice that allows you to easily integrate the planning process with our application. Try this!