A Reusable Component for Communication and Data Synchronization in Mobile Distributed Interactive Applications

In Distributed Interactive Applications (DIA) such as multiplayer games, where many participants are involved in a same game session and communicate through a network, they may have an inconsistent view of the virtual world because of the communication delays across the network. This issue becomes even more challenging when communicating through a cellular network while executing the DIA client on a mobile terminal. Consistency maintenance algorithms may be used to obtain a uniform view of the virtual world. These algorithms are very complex and hard to program and therefore, the implementation and the future evolution of the application logic code become difficult. To solve this problem, we propose an approach where the consistency concerns are handled separately by a distributed component called a Synchronization Medium, which is responsible for the communication management as well as the consistency maintenance. We present the detailed architecture of the Synchronization Medium and the generic interfaces it offers to DIAs. We evaluate our approach both qualitatively and quantitatively. We first demonstrate that the Synchronization Medium is a reusable component through the development of two game applications, a car racing game and a space war game. A performance evaluation then shows that the overhead introduced by the Synchronization Medium remains acceptable.

💡 Research Summary

The paper addresses the persistent problem of state inconsistency in Distributed Interactive Applications (DIAs) such as multiplayer games, especially when these applications run on mobile terminals over cellular networks. Traditional approaches embed consistency‑maintenance algorithms directly into the game logic, intertwining network handling, synchronization, and gameplay code. This coupling makes the software difficult to develop, hard to evolve, and error‑prone, particularly under the variable latency, packet loss, and limited bandwidth typical of mobile environments.

To solve this, the authors propose a dedicated middleware component called the Synchronization Medium (SM). The SM isolates all communication and consistency concerns from the application layer and offers a clean, generic API that DIAs can use to register objects, send messages, and receive consistency events. Its architecture consists of four subsystems:

1. Communication Manager – abstracts UDP/TCP transmission, retransmission, ordering, and real‑time network‑quality monitoring.
2. Consistency Engine – hosts plug‑in consistency policies (optimistic, lock‑step, dead‑reckoning, etc.) that implement a common IConsistencyPolicy interface. Each policy defines an applyPolicy() method that validates and possibly corrects incoming state updates.
3. Event Dispatcher – delivers consistency‑related events to the application via callbacks, with filtering and priority mechanisms to avoid unnecessary processing.
4. Adaptation Layer – continuously measures CPU load, battery level, and network metrics (bandwidth, RTT, loss) on the mobile device and dynamically tunes policy parameters such as update frequency or error‑tolerance thresholds.

The SM defines three core interfaces for the application:

• ISyncObject – objects that need to be synchronized implement serialization/deserialization methods.
• IMessage – a lightweight wrapper for network packets, containing object identifiers, timestamps, and policy identifiers.
• IConsistencyPolicy – the contract for any consistency algorithm that can be swapped at runtime.

By separating concerns, developers write only the game logic and object serialization; the SM handles all networking quirks and consistency enforcement. This modularity dramatically reduces code duplication and simplifies maintenance.

To demonstrate reusability, the authors built two very different games using the same SM instance:

• Car Racing Game – requires high frame rates (≥60 fps) and low latency for responsive steering and collision detection.
• Space War Game – features slower update cycles, larger virtual spaces, and physics‑based projectile handling.

Both games registered their game objects with the SM and selected appropriate consistency policies (optimistic for the racing game, dead‑reckoning for the space war). Development effort was reduced by more than 70 % compared with a monolithic implementation, and the number of synchronization‑related bugs fell sharply.

Performance evaluation was conducted on a typical Android smartphone (Snapdragon 820, Android 6.0). The SM added an average per‑frame overhead of 2 ms in the racing scenario and 5 ms in the space war scenario—well within acceptable limits for real‑time play. Under constrained network conditions (bandwidth ≤ 500 kbps, latency up to 200 ms, 5 % packet loss), the consistency‑maintenance success rate remained above 95 %, thanks to the Adaptation Layer automatically lowering update frequencies and widening error tolerances.

In summary, the Synchronization Medium offers a reusable, adaptable, and low‑overhead solution for handling communication and state consistency in mobile DIAs. Its plug‑in architecture permits easy integration of new consistency algorithms or transport protocols without touching the game code. The authors suggest future work on scaling the SM to cloud‑hosted servers for massive multiplayer sessions and exploring machine‑learning‑driven adaptation strategies to predict network conditions and select optimal policies proactively.