System and method for data synchronization

Abstract

The present disclosure may relate to a system (102) for data synchronization. The system may comprise a memory (204) and one or more processors (202) coupled to the memory (204). The processors (202) may be configured to execute instructions to generate, by a synchronization timing module (212), a random time interval for data synchronization when an application is launched on a user equipment (UE) (108). The processors (202) may be configured to attempt, by a data synchronization module (214), to synchronize data to a centralized server (106) at the generated random time interval. The processors (202) may be configured to retry synchronization, by the data synchronization module (214), upon occurrence of a next event in response to a failed synchronization attempt. The processors (202) may be configured to transmit, by a load balancing module (216), successfully synchronized data to one of a plurality of servers.

Description

SYSTEM AND METHOD FOR DATA SYNCHRONIZATIONRESERVATION OF RIGHTS

[0001] A portion of the disclosure of this patent document contains material, which is subject to intellectual property rights such as, but are not limited to, copyright, design, trademark, Integrated Circuit (IC) layout design, and / or trade dress protection, belonging to Jio Platforms Limited (JPL) or its affiliates (hereinafter referred as owner). The owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all rights. All rights to such intellectual property are fully reserved by the owner.FIELD OF THE DISCLOSURE

[0002] The embodiments of the present disclosure generally relate to field of wireless communication networks. The present disclosure relates to systems and methods for data synchronization. In particular, the present disclosure relates to systems and methods for passive data synchronization.DEFINITION

[0003] As used in the present disclosure, the following terms are generally intended to have the meaning as set forth below, except to the extent that the context in which they are used to indicate otherwise.

[0004] Passive data synchronization refers to the process of aligning and updating data between a user equipment and a central system without active user intervention.

[0005] User equipment (UE) refers to any device an end-user uses to communicate, such as a smartphone, tablet, or loT device capable of connecting to a mobile network.

[0006] Key performance indicators (KPIs) refer to measurable values that demonstrate how effectively a network or system is performing.

[0007] Random time interval refers to a randomly generated time period between two events or actions in the system.

[0008] Synchronization timing module is a system component that generates random time intervals for data synchronization.

[0009] Data synchronization module is a system component that manages the process of aligning data between the UE and the system.

[0010] Load balancing module is a system component that distributes incoming network traffic or data across multiple servers to ensure no single server becomes overloaded.

[0011] Data processing module is a system component that transforms raw data into a format suitable for analysis and storage.

[0012] Unorganized format refers to raw or unstructured data that has not been processed or arranged in a specific manner.

[0013] Organized format refers to data that has been processed, structured, and arranged to facilitate easy retrieval and analysis.

[0014] Distributed streaming platform cluster is a set of servers designed to handle and process large streams of data in real-time.

[0015] Streaming job is a continuous data processing task that operates on data in real-time as it is received.

[0016] Representational State Transfer Application Programming Interface (REST API) refers to an application programming interface that uses Hypertext Transfer Protocol (HTTP) requests to access and use data, conforming to the constraints of REST architectural style.

[0017] Drop wizard servers refer to Java-based servers optimized for building RESTful web services.BACKGROUND OF THE DISCLOSURE

[0018] The following description of related art is intended to provide background information pertaining to the field of the disclosure. This section may include certain aspects of the art that may be related to various features of the present disclosure. However, it should be appreciated that this section be used onlyto enhance the understanding of the reader with respect to the present disclosure, and not as admissions of prior art.

[0019] Wireless communication technology has undergone rapid evolution over the past few decades. From the first generation's analog voice services, we've progressed through 2G's text messaging and data services, 3G's high-speed internet and mobile video calling, to 4G's faster data speeds and improved network coverage. Currently, 5G technology is being deployed, offering even faster data speeds, low latency, and the ability to connect multiple devices simultaneously.

[0020] As wireless technologies advance, there is a growing need to meet 5G requirements and deliver high-level services to customers. Modern mobile devices boast powerful processors, large displays, and wireless networking capabilities. However, they still face limitations in memory capacity, data storage, and CPU capacity. With the evolution of wireless networks, mobile devices are transitioning from occasional connectivity to near-constant network connection.

[0021] Passive data collection, a methodology that collects user data without direct user participation or awareness, has become increasingly prevalent. Software Development Kits (SDKs) facilitate creation of applications that can perform such data collection. The volume of data collected from passive SDKs is typically enormous, often reaching millions of data points per day. As wireless network coverage and bandwidth increase, mobile applications increasingly rely on data synchronization with backend servers.

[0022] However, synchronizing this massive amount of data in real-time poses significant challenges. Traditional techniques for data synchronization on mobile devices often fail to handle such large volumes efficiently, leading to data leakage. This inefficiency not only results in unreliable data collection but also creates potential security risks for the network.

[0023] Current synchronization methods struggle with several issues: a. Inefficient handling of large data volumes, leading to incomplete synchronization b. Lack of real-time data processing capabilities c. Increased server load due to unoptimized synchronization attemptsd. Data security vulnerabilities arising from failed or incomplete synchronizations e. Inability to adapt to varying network conditions and device states

[0024] These limitations significantly impact the reliability and effectiveness of data collection and analysis, particularly in scenarios requiring real-time insights or involving sensitive information.

[0025] Furthermore, existing solutions often fail to consider the dynamic nature of mobile device usage. They don't account for various device states (such as screen activation or airplane mode) or network conditions, which can significantly affect data collection and synchronization processes. This oversight leads to missed data collection opportunities and inefficient use of device resources.

[0026] The lack of a sophisticated load balancing mechanism in current systems also contributes to server overload issues, potentially causing system-wide performance degradation during peak synchronization periods.

[0027] It is therefore an objective of the present invention to provide systems and methods for efficient passive data synchronization that can handle large volumes of data in real-time, adapt to varying device states and network conditions, ensure data security, and optimize server load distribution, thereby overcoming the above-mentioned disadvantages in the field.

[0028] Conventional systems and methods face difficulty in achieving efficient, secure, and adaptable passive data synchronization for mobile devices. There is, therefore, a need in the art to provide systems and methods that can overcome the shortcomings of the existing prior arts.SUMMARY OF THE DISCLOSURE

[0029] In an exemplary embodiment, a system for data synchronization is described. The system comprises a memory and one or more processors coupled to the memory. The one or more processors are configured to execute a set of instructions stored in the memory. These instructions include generate, by a synchronization timing module, a random time interval for data synchronization upon launch of an application on a user equipment (UE). Attempt, by a datasynchronization module, to synchronize data to a centralized server at the generated random time interval. Retry synchronization, by the data synchronization module, upon occurrence of a next event in response to a failed synchronization attempt. Transmit, by a load balancing module, successfully synchronized data to one of a plurality of servers.

[0030] In some embodiments, the UE is configured to capture and store data comprising network and signal key performance indicators (KPIs) upon occurrence of at least one event from a predefined set of events.

[0031] In some embodiments, the network and signal KPIs comprise at least one of: signal strength, network type, data transfer rate, latency, packet loss, network availability, network coverage, network congestion, and network switching frequency.

[0032] In some embodiments, the load balancing module randomly redirects the synchronized data to the plurality of servers.

[0033] In some embodiments, the data synchronization module is configured to restrict the synchronization attempts to once per a predetermined time period for any given event.

[0034] In some embodiments, the one or more processors further configured to process the synchronized data to convert the synchronized data from an unorganized format to an organized format and store the processed synchronized data in a database.

[0035] In some embodiments, the next event for retry synchronization is defined as an occurrence of the at least one event for capturing the data.

[0036] In another exemplary embodiment, a method for data synchronization is described. The method comprises generating, by a synchronization timing module, a random time interval for data synchronization upon launch of an application on a user equipment (UE). Attempting, by a data synchronization module, to synchronize data to a centralized server at the generated random time interval. Retrying synchronization, by the data synchronization module, upon occurrence of a next event in response to a failed synchronizationattempt. Transmitting, by a load balancing module, successfully synchronized data to one of a plurality of servers.

[0037] In a further exemplary embodiment, a user equipment communicatively coupled to a network is described. The coupling comprises steps of receiving, by the network, a connection request from the UE, sending, by the network, an acknowledgment of the connection request to the UE and transmitting a plurality of signals in response to the connection request. The data synchronization in the network is performed by a method that comprises generating, by a synchronization timing module, a random time interval for data synchronization upon launch of an application on a user equipment (UE). Attempting, by a data synchronization module, to synchronize data to a centralized server at the generated random time interval. Retrying synchronization, by the data synchronization module, upon occurrence of a next event in response to a failed synchronization attempt. Transmitting, by a load balancing module, successfully synchronized data to one of a plurality of servers.

[0038] In yet another exemplary embodiment, the present disclosure discloses a computer program product comprising a non-transitory computer- readable medium comprising instructions that, when executed by one or more processors, cause the one or more processors to perform a method for data synchronization. The method comprises generating, by a synchronization timing module, a random time interval for data synchronization upon launch of an application on a user equipment (UE). Attempting, by a data synchronization module, to synchronize data to a centralized server at the generated random time interval. Retrying synchronization, by the data synchronization module, upon occurrence of a next event in response to a failed synchronization attempt. Transmitting, by a load balancing module, successfully synchronized data to one of a plurality of servers.

[0039] The foregoing general description of the illustrative embodiments and the following detailed description thereof are merely exemplary aspects of the teachings of this disclosure and are not restrictive.OBJECTIVES OF THE DISCLOSURE

[0040] Some of the objectives of the present disclosure, which at least one embodiment herein satisfies are as listed herein below.

[0041] An objective of the present disclosure is to provide a system and a method for data synchronization that efficiently handles large volumes of data.

[0042] An objective of the present disclosure is to provide a system and a method for data synchronization that ensures data integrity and prevents data leakage.

[0043] An objective of the present disclosure is to provide a system and a method that generates a random time interval for data synchronization, optimizing network resources and reducing server load.

[0044] An objective of the present disclosure is to provide a system and a method for retrying synchronization upon occurrence of a next event, ensuring data completeness in varying network conditions.

[0045] An objective of the present disclosure is to randomly redirect synchronized data to a plurality of servers, enhancing system reliability and performance.

[0046] An objective of the present disclosure is to convert synchronized data from an unorganized format to an organized format suitable for efficient storage and analysis.

[0047] An objective of the present disclosure is to enable the capture and storage of data comprising network and signal key performance indicators (KPIs) upon the occurrence of specific events.

[0048] An objective of the present disclosure is to provide a system and a method that allows for analytics and reporting, based on the stored processed synchronized data.BRIEF DESCRIPTION OF DRAWINGS

[0049] The accompanying drawings, which are incorporated herein, and constitute a part of this disclosure, illustrate exemplary embodiments of the disclosed methods and systems in which like reference numerals refer to the sameparts throughout the different drawings. Components in the drawings are not necessarily to scale, emphasis instead being placed upon clearly illustrating the principles of the present disclosure. Some drawings may indicate the components using block diagrams and may not represent the internal circuitry of each component. It will be appreciated by those skilled in the art that disclosure of such drawings includes the disclosure of electrical components, electronic components or circuitry commonly used to implement such components.

[0050] FIG. 1 illustrates an exemplary network architecture for data synchronization, in accordance with embodiments of the present disclosure.

[0051] FIG. 2 illustrates an exemplary micro service-based architecture of a system for data synchronization, in accordance with embodiments of the present disclosure.

[0052] FIG. 3 illustrates an exemplary flow diagram of a method for data synchronization, in accordance with embodiments of the present disclosure.

[0053] FIG. 4 illustrates an exemplary architecture of a system for data synchronization, in accordance with embodiments of the present disclosure.

[0054] FIG. 5 illustrates an exemplary flowchart of a method for data synchronization, in accordance with embodiments of the present disclosure.

[0055] FIG. 6 illustrates an exemplary computer system in which or with which embodiments of the present disclosure may be implemented.

[0056] The foregoing shall be more apparent from the following more detailed description of the disclosure.LIST OF REFERENCE NUMERALS100 - Network architecture102 - System104- Network106 - Centralized server108-1, 108-2... 108-N - User equipment(s)110-1, 110-2...110-N - Users200- System architecture202 - One or more processor(s)204- Memory206 - I / O interface(s)208 - Processing module(s)210 - Database212- Synchronization timing module214- Data synchronization module216-Load balancing module218- Data processing module220- Other module(s)300- Flow diagram400- System architecture500- Flowchart610 - External Storage Device620 - Bus630 - Main Memory640 - Read Only Memory650 - Mass Storage Device660 - Communication Port670- ProcessorDETAILED DESCRIPTION OF THE DISCLOSURE

[0057] In the following description, for the purposes of explanation, various specific details are set forth in order to provide a thorough understanding of embodiments of the present disclosure. It will be apparent, however, that embodiments of the present disclosure may be practiced without these specific details. Several features described hereafter can each be used independently of one another or with any combination of other features. An individual feature may not address all of the problems discussed above or may address only some of the problems discussed above. Some of the problems discussed above may not be fully addressed by any of the features described herein.

[0058] The ensuing description provides exemplary embodiments only, and is not intended to limit the scope, applicability, or configuration of the disclosure. Rather, the ensuing description of the exemplary embodiments will provide those skilled in the art with an enabling description for implementing an exemplary embodiment. It should be understood that various changes may be made in the function and arrangement of elements without departing from the spirit and scope of the disclosure as set forth.

[0059] Specific details are given in the following description to provide a thorough understanding of the embodiments. However, it will be understood by one of ordinary skill in the art that the embodiments may be practiced without these specific details. For example, circuits, systems, networks, processes, and other components may be shown as components in block diagram form in order not to obscure the embodiments in unnecessary detail. In other instances, well-known circuits, processes, algorithms, structures, and techniques may be shown without unnecessary detail in order to avoid obscuring the embodiments.

[0060] Also, it is noted that individual embodiments may be described as a process which is depicted as a flowchart, a flow diagram, a data flow diagram, a structure diagram, or a block diagram. Although a flowchart may describe the operations as a sequential process, many of the operations can be performed in parallel or concurrently. In addition, the order of the operations may be re-arranged. A process is terminated when its operations are completed but could have additional steps not included in a figure. A process may correspond to a method, a function, a procedure, a subroutine, a subprogram, etc. When a process corresponds to a function, its termination can correspond to a return of the function to the calling function or the main function.

[0061] The word “exemplary” and / or “demonstrative” is used herein to mean serving as an example, instance, or illustration. For the avoidance of doubt, the subject matter disclosed herein is not limited by such examples. In addition, any aspect or design described herein as “exemplary” and / or “demonstrative” is not necessarily to be construed as preferred or advantageous over other aspects or designs, nor is it meant to preclude equivalent exemplary structures and techniquesknown to those of ordinary skill in the art. Furthermore, to the extent that the terms “includes,” “has,” “contains,” and other similar words are used in either the detailed description or the claims, such terms are intended to be inclusive in a manner similar to the term “comprising” as an open transition word without precluding any additional or other elements.

[0062] Reference throughout this specification to “one embodiment” or “an embodiment” or “an instance” or “one instance” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present disclosure. Thus, the appearances of the phrases “in one embodiment” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0063] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the disclosure. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and / or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and / or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof. As used herein, the term “and / or” includes any and all combinations of one or more of the associated listed items.

[0064] The aspects of the present disclosure are directed to a system and a method for data (passive data) synchronization that efficiently handles large volumes of data while optimizing network resources and server load. The disclosure introduces a novel approach utilizing a random time interval for synchronization and event-based retry mechanisms to ensure data integrity and prevent data leakage. Additionally, the disclosure presents a load-balancing technique that randomly redirects synchronized data (passive data) across multiple servers, thereby enhancing system reliability and performance while enabling real-time processingand analysis of network and signal key performance indicators (KPIs) captured from the user equipment.

[0065] The various embodiments throughout the disclosure will be explained in more detail with reference to FIGS. 1-6.

[0066] FIG. 1 illustrates an exemplary network architecture 100 for data synchronization, in accordance with embodiments of the present disclosure.

[0067] As illustrated in FIG. 1, one or more user equipment (108-1, 108- 2...108-N) may be connected to a system (102) for data synchronization through a network (104). In an embodiment the data may include a passive data. A person of ordinary skill in the art will understand that the one or more user equipment (108- 1, 108-2...108-N) may be collectively referred to as UEs (108) and individually referred to as a UE (108). One or more users may provide passive data to the system (102) through various sensors embedded in the UE (108).

[0068] In an embodiment, the UE (108) may include, but not be limited to, a mobile phone, a laptop, etc. Further, the UE (108) may include one or more inbuilt or externally coupled sensors for capturing network and signal key performance indicators (KPIs). Furthermore, the UE (108) may include a smartphone, virtual reality (VR) devices, augmented reality (AR) devices, a general -purpose computer, a desktop, a personal digital assistant, a tablet computer, and a mainframe computer. In an exemplary embodiment, the UE (108) may be communicatively coupled to the network. The coupling comprises steps of receiving, by the network, a connection request from the UE, sending, by the network, an acknowledgment of the connection request to the UE and transmitting a plurality of signals in response to the connection request.

[0069] In an embodiment, the network (104) may include, by way of example but not limitation, at least a portion of one or more networks having one or more nodes that transmit, receive, forward, generate, buffer, store, route, switch, process, or a combination thereof, etc. one or more messages, packets, signals, waves, voltage or current levels, some combination thereof, or so forth. The network (104) may also include, by way of example but not limitation, one or more of a wireless network, a wired network, an internet, an intranet, a public network, aprivate network, a packet-switched network, a circuit-switched network, an ad hoc network, an infrastructure network, a 2G network, a 3G network, a 4G network, a 5G network, a 6G network, or some combination thereof. The system (102) may be connected to a centralized server (106).

[0070] In an embodiment, the system (102) may continuously collect passive data from a selected UE (108) when at least one event from a predefined set of events occurs. The UE (108) is configured to capture and store the passive data comprising network and signal key performance indicators (KPIs) upon occurrence of the at least one event from the predefined set of events. The synchronization timing module (212) may generate a random time interval for passive data synchronization upon launch of an application on the UE (108). The data synchronization module (214) may attempt to synchronize the passive data to the centralized server (106) at the generated random time interval. If synchronization fails, the data synchronization module (214) may retry synchronization upon occurrence of a next event. The load balancing module (216) may then transmit the successfully synchronized passive data to one of a plurality of servers. The data processing module (218) may process the synchronized passive data to convert it from an unorganized format to an organized format.

[0071] Although FIG. 1 shows exemplary components of the network architecture (100), in other embodiments, the network architecture (100) may include fewer components, different components, differently arranged components, or additional functional components than depicted in FIG. 1. Additionally, or alternatively, one or more components of the network architecture (100) may perform functions described as being performed by one or more other components of the network architecture (100).

[0072] FIG. 2 illustrates an exemplary micro service-based architecture of a system (102) for data synchronization, in accordance with embodiments of the present disclosure.

[0073] Referring to FIG. 2, in an embodiment, the system (102) may include one or more processor(s) (202). The one or more processor(s) (202) may be implemented as one or more microprocessors, microcomputers, microcontrollers,digital signal processors, central processing units, logic circuitries, and / or any devices that process data based on operational instructions. Among other capabilities, the one or more processor(s) (202) may be configured to fetch and execute computer-readable instructions stored in a memory (204) of the system (102). The memory (204) may be configured to store one or more computer- readable instructions or routines in a non-transitory computer readable storage medium, which may be fetched and executed to synchronize passive data and process it. The memory (204) may comprise any non-transitory storage device including, for example, volatile memory such as random-access memory (RAM), or non-volatile memory such as erasable programmable read only memory (EPROM), flash memory, and the like.

[0074] In an embodiment, the system (102) may include an interface(s) (206). The interface(s) (206) may comprise a variety of interfaces, for example, interfaces for data input and output devices (I / O), storage devices, and the like. The interface(s) (206) may facilitate communication through the system (102). The interface(s) (206) may also provide a communication pathway for one or more components of the system (102). Examples of such components include, but are not limited to, processing module(s) (208) and a database (210) for storing synchronized data. Further, the processing module(s) (208) may include a synchronization timing module (212), a data synchronization module (214), a load balancing module (216), a data processing module (218), and other modules (220).

[0075] The other module(s) (220) may encompass various additional functionalities that support the overall operation of the system (102) for passive data synchronization. These may include, but are not limited to, a security module for data encryption, a data compression module, a power management module to optimize battery usage, and a network analysis module. These modules work in concert with the primary modules to enhance the robustness, efficiency, and reliability of the system (102).

[0076] The synchronization timing module (212) may generate a random time interval for passive data synchronization to the centralized server (106) upon launch of an application on the UE (108). The UE (108) is configured to captureand store passive data comprising network and signal key performance indicators (KPIs) upon occurrence of at least one event from a predefined set of events. For example, the UE (108) is configured to monitor the occurrence of at least one event for capturing passive data. The predefined set of events may include at least one of: screen activation, airplane mode toggling, Global Positioning System (GPS) status change, and network switching. In examples, the network and signal KPIs may include at least one of: signal strength, network type, data transfer rate, latency, packet loss, network availability, network coverage, network congestion, and network switching frequency. According to an implementation, the synchronization timing module (212) may collect the passive data from the UE (108).

[0077] The data synchronization module (214) may attempt to synchronize the passive data to the centralized server (106) at the generated random time interval and retry synchronization upon occurrence of a next event in response to a failed synchronization attempt. The next event may be defined as an occurrence of the at least one event for capturing passive data. The data synchronization module (214) is configured to restrict the synchronization attempts to once per a predetermined time period for any given event. The load balancing module (216) may transmit successfully synchronized passive data to one of a plurality of servers. The load balancing module (216) randomly redirects the synchronized passive data to the plurality of servers. The data processing module (218) may process the synchronized passive data to convert it from an unorganized format to an organized format. In an implementation, the data processing module (218) executes a streaming job to convert the synchronized passive data from the unorganized format to the organized format. The streaming job is a continuous synchronized passive data processing operation that operates in real-time. The data processing module (218) stores the processed synchronized passive data in the database (210). The stored processed synchronized passive data may be utilized for analytics and reporting. According to an implementation, the one or more processors (202) is configured to store the synchronized passive data in a distributed streaming platform cluster before processing by the data processing module (218). Thedistributed streaming platform cluster comprises a set of servers configured to store and process large streams of the synchronized passive data in real-time.

[0078] In an embodiment, the processing module(s) (208) may be implemented as a combination of hardware and programming (for example, programmable instructions) to implement one or more functionalities of the processing module(s) (208). In examples described herein, such combinations of hardware and programming may be implemented in several different ways. For example, the programming for the processing module(s) (208) may be processorexecutable instructions stored on a non-transitory machine-readable storage medium and the hardware for the processing module(s) (208) may comprise a processing resource (for example, one or more processors), to execute such instructions. In the present examples, the machine-readable storage medium may store instructions that, when executed by the processing resource, implement the processing module(s) (208). In such examples, the system may comprise the machine-readable storage medium storing the instructions and the processing resource to execute the instructions, or the machine-readable storage medium may be separate but accessible to the system and the processing resource. In other examples, the processing module(s) (208) may be implemented by electronic circuitry.

[0079] Although FIG. 2 shows exemplary components of the system (102), in other embodiments, the system (102) may include fewer components, different components, differently arranged components, or additional functional components than depicted in FIG. 2. Additionally, or alternatively, one or more components of the system (102) may perform functions described as being performed by one or more other components of the system (102).

[0080] The present disclosure may relate to a system (102) and a method (500) for passive data synchronization. The system (102) may comprise a memory (204) and one or more processors (202) coupled to the memory (204). The one or more processors (202) may be configured to execute a set of instructions stored in the memory (204) to perform various operations for passive data synchronization.

[0081] The memory (204) in the system (102) may be a non-transitory computer-readable storage medium. It may include, but is not limited to, RAM, ROM, EEPROM, flash memory, or any other suitable memory technology. The memory (204) may store instructions and data used by the processors (202).

[0082] The one or more processors (202) may be implemented using any suitable processing technology, such as microprocessors, CPUs, ASICs, FPGAs, or any other processing devices capable of executing instructions and processing data. The processors (202) may be coupled to the memory (204) via a bus or other suitable connection.

[0083] The synchronization timing module (212) may be a software module, or a hardware component configured to generate random time intervals. These intervals may be used to determine when passive data synchronization should be attempted. For example, the synchronization timing module (212) may generate random time between 1 and 24 hours after an application is launched on the UE (108). The randomness may be achieved through various conventional methods to ensure unpredictability and even distribution. In an example, the synchronization timing module (212) may utilize a cryptographically secure pseudorandom number generator (CSPRNG) to produce a random number within the desired range. Alternatively, the synchronization timing module (212) may utilize system entropy sources, such as device sensor data, network packet timing, or user interaction patterns, as seeds for random time generation. The generated random time may also be influenced by factors such as the current network conditions, battery level, or historical synchronization patterns to optimize the timing while maintaining randomness. This randomization helps to distribute the synchronization load across time, preventing predictable spikes in server load and enhancing the overall efficiency and security of the data synchronization process.

[0084] In this context, an application may refer to any software program running on the UE (108). The launch of an application may be defined as the moment when the application starts running, either by user action or system initiation. For instance, this could be when a user opens a specific application on the UE (108), or when a background service starts running.

[0085] For example, passive data synchronization may refer to the process of aligning and updating data between the UE (108) and the centralized server (106) without active user intervention. The passive data synchronization process ensures that the latest data collected on the UE (108) is transferred to the database (210) for analysis and storage.

[0086] In an embodiment, when an application is launched on the UE (108), the synchronization timing module (212) may generate a random time interval for passive data synchronization. The UE (108) may be configured to capture (or collect) and store passive data comprising network and signal key performance indicators (KPIs) upon occurrence of at least one event from a predefined set of events. For example, passive data collection, as used herein, may refer to a methodology that collects user data without the user's direct participation. Passive data collection may occur without the user's awareness. This approach may allow for collecting large volumes of real-world data without burdening the user.

[0087] The passive data captured by the UE (108) may include various network and signal KPIs. These KPIs may comprise signal strength which may indicate the power level of received radio signals). For example, signal strength may be measured in decibel-milliwatts (dBm) and may range from approximately -30 dBm (very strong) to -110 dBm (very weak). Network type may also be included, potentially differentiating between cellular technologies like 3G, 4G, or 5G. Data transfer rate may be another KPI, measuring the speed at which data is transmitted, typically in bits per second (bps) or a derivative unit like Mbps. Latency may be another KPI. Latency represents delays in data transmission and may be measured in milliseconds (ms). The UE (108) may additionally record packet loss, which occurs when data packets fail to reach their destination, often expressed as a percentage of total packets sent. Network availability and coverage may be monitored to assess service reliability across different locations, potentially representing a percentage of time or geographic area with service. Network congestion levels may be tracked to identify periods of high traffic, possibly measured by metrics like packet delay or throughput reduction. The frequency of network switching between different cellular towers or Wi-Fi access points mayalso be recorded as a KPI, potentially measured as the number of switches per unit of time or distance travelled.

[0088] The predefined set of events triggering passive data capture may encompass various device and network state changes. Screen activation may be one such event, potentially indicating the start of an active usage session. This could be valuable for correlating network performance with active device usage. Airplane mode toggling may trigger data capture, as it represents a significant change in network connectivity. This event may provide insights into network re-acquisition times and performance immediately after reconnection. Global Positioning System (GPS) status changes may be another trigger, possibly correlating with locationbased network performance variations. For instance, entering or leaving a building may trigger this event, allowing for indoor vs. outdoor network performance analysis. Network switching events, such as transitioning between cellular and WiFi networks, may also initiate passive data capture. This could provide valuable data on the comparative performance of different network types and the smoothness of transitions between them. The system (102) may include a data synchronization module (214) configured to attempt synchronization of the passive data to the centralized server (106) at the generated random time interval. If the synchronization attempt fails, the data synchronization module (214) may retry synchronization upon the occurrence of the next event. The next event for retry synchronization may be defined as an occurrence of the at least one event for capturing passive data. This approach may ensure that synchronization attempts are tied to meaningful changes in device state or network conditions, rather than occurring at arbitrary intervals. For instance, if a synchronization attempt fails due to poor network connectivity, the system (102) may wait until the next network switching event (e.g., moving from cellular to Wi-Fi) before attempting to synchronize again. This approach may help ensure data is eventually synchronized while avoiding constant synchronization attempts that could drain device resources.

[0089] The data synchronization module (214) may be responsible for managing the actual process of data transfer between the UE (108) and the centralized server (106). The data synchronization module (214) may use variousnetwork protocols to ensure reliable and secure data transmission. For example, the data synchronization module (214) may use HTTPS for secure data transfer over the internet.

[0090] A synchronization attempt may be considered failed if, for instance, the UE (108) is unable to establish a connection with the centralized server (106), if the data transfer is interrupted, or if the centralized server (106) fails to acknowledge receipt of the data. In such cases, the data synchronization module (214) may log the failure and prepare for a retry later.

[0091] To manage synchronization frequency, the data synchronization module (214) may be further configured to restrict synchronization attempts to once per a predetermined time period for any given event. For example, the system (102) may limit synchronization attempts to once every 24 hours for data related to a specific event type. This restriction may help balance the need for up-to-date data with network usage and device battery life considerations.

[0092] The UE (108) may be configured to monitor the occurrence of events that trigger passive data capture. After successful synchronization to the centralized server (106), the UE (108) may delete the stored passive data. This approach may help manage storage space on the UE (108) while ensuring that synchronized data is retained in the system’s database (210). For instance, if the UE (108) has successfully synchronized 10 MB of passive data, it may then delete this data from its local storage, freeing up space for future data collection.

[0093] The load balancing module (216) in the system (102) may be responsible for transmitting successfully synchronized passive data to one of a plurality of servers (106). The load balancing module (216) may randomly redirect the synchronized passive data to the plurality of servers (106). This random redistribution may help prevent any single server from becoming overloaded with data processing tasks, potentially improving overall system performance and reliability. For example, if the system (102) has 10 servers, each synchronization request may be randomly assigned to one of these servers, ensuring a relatively even distribution of processing load.

[0094] The load balancing module (216) may be a component of the system (102) that distributes incoming data across multiple servers to ensure efficient processing and storage. It may use various algorithms to determine how to distribute the load. For example, the load balancing module (216) may use a round-robin approach, where each new set of data is sent to the next server in a circular list, or it may use more complex algorithms that take into account current server load and capacity.

[0095] The data processing module (218) may be responsible for transforming the raw data received from the UE (108) into a format that is more suitable for analysis and storage, i.e., from an unorganized format into an organized format. This transformation may involve various operations such as data cleaning, normalization, aggregation, or feature extraction. An unorganized format, in this context, may refer to raw data as it is collected on the UE (108). This could be in various formats depending on how it is captured, such as JavaScript Object Notation (JSON), Comma Separated Value (CSV), or even plain text logs. An organized format, on the other hand, may be a structured database schema, where each type of data has a predefined place and relationship to other data points.

[0096] The database (210) may be any type of data storage system capable of storing large amounts of structured data. This could be a relational database like My Structured Query Language (MySQL) or PostgreSQL, a NoSQL database depending on the specific requirements of the system.

[0097] Before processing of the synchronized data by the data processing module (218), the system (102) may store the synchronized passive data in a distributed streaming platform cluster. This cluster may comprise a set of servers configured to store and process large streams of the synchronized passive data in real-time. Utilizing a distributed streaming platform may enable the system (102) to handle high volumes of incoming data efficiently.

[0098] The data processing module (218) may execute a streaming job to convert the synchronized passive data from an unorganized format to an organized format. This streaming job may be a continuous synchronized passive data processing operation that operates in real-time as the synchronized passive data isreceived. Real-time processing may allow for timely analysis and reporting based on the latest synchronized data. For instance, the streaming job may take raw JSON data from the UE (108) and convert it into a structured format suitable for database storage and quick querying.

[0099] After processing, the system (102) may store the processed data in a database (210). This centralized storage may facilitate easy access for further analysis and reporting purposes. The system (102) may be configured to utilize the stored processed data for analytics and reporting, potentially providing valuable insights into network performance and user behavior. For example, the system (102) may generate daily reports on average signal strength across different network types and geographic areas.

[0100] The system (102) and method (500) described may provide several potential benefits. By using random time intervals for synchronization and load balancing across multiple servers, the system may help distribute network load and prevent server overload. The event-based triggering of data capture and synchronization may allow for efficient use of device resources while still collecting comprehensive network performance data.

[0101] Real-time processing of synchronized data may enable timely insights into network performance. This could potentially allow network operators to identify and address issues, improving overall service quality quickly. For example, if the system (102) detects a sudden increase in latency in a particular area, network operators could be alerted immediately to investigate and resolve the issue.

[0102] The storage of processed data in an organized format may facilitate more efficient analysis and reporting, potentially leading to better-informed decision making. For instance, the organized data may allow for the quick generation of reports on network performance trends over time or performance comparisons across different device types or geographic regions.

[0103] The ability of the system (102) to capture a wide range of network and signal KPIs may provide a comprehensive view of network performance from the user's perspective. This user-centric data may complement traditional networkmonitoring tools, offering insights into the real-world user experience. For example, while network equipment may report good signal strength in an area, user devices may be experiencing poor data rates due to congestion or interference.

[0104] By deleting local data after successful synchronization, the system (102) may help manage storage on user devices while still ensuring that valuable performance data is retained in the central database (210). This approach may balance data collection needs and user device resource management. For instance, a user having a device with limited storage may be able to contribute valuable network performance data without worrying about filling up their device's storage.

[0105] The use of a distributed streaming platform for initial data storage may allow the system (102) to handle large volumes of incoming data efficiently. This scalability may be particularly valuable as the number of connected devices and the volume of network traffic continues to grow. For example, the system (102) may be able to handle data from millions of devices, each sending multiple data points per day, without significant performance degradation.

[0106] The ability of the system (102) to restrict synchronization attempts to once per predetermined time period for any given event may help prevent excessive network usage or battery drain on user devices. This approach for data collection may help ensure that the passive monitoring does not negatively impact the user experience. For instance, even if a user's device experiences frequent network switches, the system (102) would not attempt to synchronize more than once per day for this event type, preserving battery life and network bandwidth.

[0107] The system (102) and method (500) for passive data synchronization may offer a comprehensive approach for collecting, processing, and analyzing network performance data. By leveraging user devices to collect real-world performance data, balancing data collection needs with device resource management, and employing efficient data processing techniques, the system (102) may provide valuable insights to improve network performance and user experience across various network types and conditions.

[0108] In an aspect, the present invention may disclose the usage of mobile application calls along with a background application programming interface (API)call. The API may be called when a synchronization call is performed by the system (102). After hitting the API from the UE (108), the backend process may be executed. Thus, the present disclosure discloses a technology that includes mobile application functionality, backend API integration, and backend architecture (e.g., batch job processing).

[0109] FIG. 3 may illustrate an exemplary flow diagram (300) for a method for data synchronization, in accordance with an embodiment of the present disclosure.

[0110] In an aspect, at step 302, the UE (108) may perform data capturing. The UE (108) may continuously collect passive data, including network and signal key performance indicators (KPIs), without active user intervention. This data may provide valuable insights into real-world network performance.

[0111] In an aspect, at step 304, a data synchronization call may be performed on a screen ON event. This event may be chosen as it often correlates with active device usage, potentially capturing data during periods of high network demand. Other events that may trigger data capture could include airplane mode toggling or network switching.

[0112] In an aspect, at step 306, in instances where data synchronization is successful, a random time interval for the next data synchronization may be generated. This randomization may help distribute the synchronization load across time, preventing predictable spikes in server load.

[0113] In an aspect, at step 308, when data synchronization fails, a retry of the data synchronization may be performed after the occurrence of a next event. This approach ensures data integrity even in challenging network conditions, balancing the need for up-to-date data with system resource considerations.

[0114] In an aspect, at step 310, an API call hit may be passed to a load balancing module (216) after a random time interval for data synchronization is generated. This step may initiate the process of transmitting synchronized passive data to the system's servers.

[0115] In an aspect, at step 312, the API call hits may be redirected to any one of the servers (out of 'n' servers). The servers may be dropwizard servers,optimized for handling RESTful API requests efficiently. This distribution of incoming data across multiple servers enhances the system's ability to handle large data volumes.

[0116] In an aspect, at step 314, the data may be processed and stored in a distributed streaming platform in an unorganized format. This initial storage allows for rapid ingestion of large data volumes, preparing it for more detailed processing.

[0117] In an aspect, at step 316, the data may be processed into an organized format from the unorganized format using a streaming job. This continuous operation transforms the raw data into a structured format more suitable for analysis and long-term storage.

[0118] In an aspect, at step 318, the processed data in an organized format may be stored in a database (210). The database (210) may be column-oriented and non-relational (HBase), chosen for its ability to handle large volumes of data with fast read and write operations.

[0119] In an aspect, the data from the software development kit (SDK) (e.g., a passive SDK) may be synchronized on a server every 'n' hours (e.g., 24 hours), which may be randomized at the user's end. The data may be queued at a server end to serve a huge user base from the time of the first launch of an application on the UE (108). If data synchronization fails, a retry of the data synchronization may be made after the occurrence of the next event.

[0120] In an aspect, the data capturing may be performed every 'm' minutes (e.g., 15 mins) in case the UE (108) screen is ON. This approach balances the need for frequent data collection with power conservation considerations. The present disclosure may collect approximately 10Kb of data per day per user, providing a dataset without consuming the device's storage or the user's data plan.

[0121] In an aspect, the present invention may disclose generating a random synchronized time interval for every UE (108). The number of data synchronization attempts for any event may be restricted to only ONCE in 'n' hours (e.g., 24 hours). For example, if data synchronization is successful upon application launch at 12 PM 11 -April-2018, then the next data synchronization attempt may be performed after 12 PM 12-April-2018. In this case, data synchronization may not be attemptedat random synchronization time and silent notification receipt if falling in the 24- hour window.

[0122] In an aspect, the file size of the application before installation may be approximately 300 kilobytes (KB), and the file size after installation may be approximately 500 KB. This helps ensure the application does not significantly impact the UE's storage capacity.

[0123] In an aspect, the collected passive data may be stored in the internal storage of the UE (108) with a file size limit of 1 Megabyte (MB). After the data has been synchronized to the centralized server (106), the previously existing file may be deleted, freeing up space for future data collection.

[0124] The present invention may disclose a system (102) and a method (500) that is applicable to 2G, 3G, 4G, 5G, 6G, and further generations of mobile technology with multiple bands and carriers of various telecommunication operators. This broad applicability ensures the system remains relevant as network technologies evolve.

[0125] FIG. 4 illustrates an exemplary architecture (400) of a system for data synchronization, in accordance with embodiments of the present disclosure.

[0126] In an aspect, the passive data, including all network and signal key performance indicators (KPIs), may be captured and stored in the end user's mobile device, referred to as the user equipment (UE) (108). The UE (108) may be configured to capture and store this passive data upon occurrence of at least one event from a predefined set of events. The data, in the form of rows, may be captured on an event basis. These events may include, but are not limited to, screen activation, airplane mode toggling, Global Positioning System (GPS) status changes, and network switching. The network and signal KPIs may comprise signal strength, network type, data transfer rate, latency, packet loss, network availability, network coverage, network congestion, and network switching frequency.

[0127] Once data is captured on a given day (say T day), on the subsequent day (T+T) when the mobile application (402) is launched, the synchronization timing module (212) may generate a random time interval for passive data synchronization. This randomization may help distribute the synchronization loadacross time, preventing predictable spikes in server load. The system (102) may generate a random synchronized time for every UE, with the number of data synchronization attempts for any event restricted to only ONCE in 'n' hours (e.g., 24 hours).

[0128] In case the data synchronization fails, the data synchronization module (214) may attempt to retry synchronization after the occurrence of the next event. This approach ensures data integrity even in challenging network conditions, balancing the need for up-to-date data with system resource considerations. The data may be temporarily stored in a file on the UE (108). The UE (108) may be configured to monitor the occurrence of events for capturing passive data and delete the stored passive data after successful synchronization to the centralized server (106).

[0129] When data synchronization is successful, the load balancing module (216) may transmit the successfully synchronized passive data to the load balancer (404). The load balancer (404) is a device or software that distributes network or application traffic across different servers. In this context, the load balancer (404) may then randomly redirect the synchronized data to different servers (406) from a pool of 'n' servers. For example, if there are 10 servers in the pool, the load balancer (404) may use a round-robin algorithm to distribute incoming data evenly, or it may use any conventional method that takes into account the current server load. This random distribution helps ensure that no single server becomes overloaded with synchronized data, thereby maintaining system efficiency and reliability.

[0130] The servers (406) may include a REST API for microservices. A REST API (also called a RESTful API or RESTful web API) is an application programming interface that conforms to the design principles of the representational state transfer (REST) architectural style. REST is an architectural style that defines a set of constraints to be used for creating web services. REST API is a way of accessing web services in a simple and flexible way without having any processing. For example, a REST API may allow a client to retrieve user data by sending a GET request to a URL like "https: / / api.example.com / users / 123". Theservers may also include a distributed streaming platform producer to handle large volumes of data efficiently.

[0131] The servers (406) may be implemented as drop wizard servers, which are optimized for handling RESTful API requests efficiently. Dropwizard is a Java framework for developing high-performance, restful web services. It integrates several popular and battle-tested Java libraries and frameworks, allowing developers to quickly create production-ready RESTful web services. After processing by the servers, the data may be sent to a distributed streaming platform cluster (408), where it is initially stored in an unorganized or non-readable format. This unorganized format may be a binary format or a serialized object format that is optimized for quick storage but not human-readable.

[0132] The distributed streaming platform cluster (408) may include a topic associated with the data and a data integration framework. In the context of a distributed streaming platform, it consists of a topic, which is a category or feed name to which records are published. For example, there may be separate topics for "network_performance_data" and "user_activity_data". This setup allows for efficient handling and processing of large data streams. The data integration framework may be a tool, which can process and route data between different systems. The data synchronization process may be performed under a trusted zone of a firewall, which represents a group of network addresses from which the firewall allows some inbound traffic using default settings, ensuring data security. For instance, the firewall may be configured to allow inbound traffic only from IP addresses known to belong to the system's servers or authorized client devices.

[0133] Subsequently, the data processing module (218) may process the data through a streaming job (410). The 'myapppassive streaming' operation performed by the streaming job may include job details associated with the topic. This streaming job converts the synchronized passive data from an unorganized format to an organized format, operating in real-time as the synchronized passive data is received. The streaming job may be a continuous synchronized passive data processing operation.

[0134] After processing, the data may be stored in a database (412), such as an HBase database, in an organized and readable format, categorized user- wise. This processed and stored data may then be used for further reporting and analysis purposes. The system (102) may be configured to utilize the stored processed data for analytics and reporting.

[0135] The present invention may enable the synchronization of significant amounts of passive data (in millions) in the backend. The data stored in the backend may be processed and stored in a readable format, which can later be used for analytics and reporting, providing valuable insights into network performance and user behavior.

[0136] The system (102) may avoid data leakage by generating random time intervals for synchronization, thereby reducing the burden on the servers. The randomization of data synchronization may help prevent server overload, ensuring efficient system performance.

[0137] The stored data may be used by organizations for user profiling, offering insights into user behavior and preferences. Additionally, the stored data may include network, signal, and device-related information that can be used for network performance monitoring and optimization.

[0138] The system and method of synchronizing data described in this invention may be broadly applicable in organizations where large amounts of data are processed. It provides an improved architecture for storing significant amounts of data in a readable format and offers an enhanced flow and working mechanism for passive synchronized API.

[0139] This system may be applicable across multiple generations of mobile technology, including 2G, 3G, 4G, 5G, 6G, and beyond, with compatibility for multiple bands and carriers from various telecommunication operators. This broad applicability ensures the system remains relevant as network technologies evolve.

[0140] FIG. 5 illustrates an exemplary flowchart of a method (500) for data synchronization, in accordance with embodiments of the present disclosure.

[0141] At step (502), the method (500) includes generating, by the synchronization timing module (212), a random time interval for datasynchronization upon launch of an application on a user equipment (UE) (108). In an embodiment, the data may comprise a passive data. The process of generating the random time interval begins when an application launches, at which point the system initializes a time generation protocol. The system then retrieves several current device parameters from the user equipment, including the current time stamp, device identifier, network status, and battery level. Using these collected parameters, the system generates a seed value by combining them according to predefined algorithms. This seed value is then input into a pseudo-random number generator to create an initial time value. The system applies specific constraints to this generated time to ensure it falls within acceptable bounds, such as within the next 24 hours of operation. Following the generation, the system validates the proposed time against any existing scheduled synchronizations to avoid conflicts. Once validated, the system stores this generated time interval in memory for future reference. In cases where the generated time is determined to be invalid or conflicts with existing scheduled synchronizations, the system automatically repeats the entire generation process until a valid time interval is produced. This comprehensive process ensures the generation of appropriate and conflict-free random time intervals for data synchronization while considering the device's current state and existing schedules.

[0142] The UE (108) is configured to capture and store passive data comprising network and signal key performance indicators (KPIs) upon occurrence of at least one event from a predefined set of events. The network and signal KPIs may include signal strength, network type, data transfer rate, latency, packet loss, network availability, network coverage, network congestion, and network switching frequency. The predefined set of events triggering passive data capture may comprise screen activation, airplane mode toggling, Global Positioning System (GPS) status change, and network switching. This randomization helps distribute the synchronization load across time, preventing predictable spikes in server load.

[0143] At step (504), the method (500) includes attempting, by the data synchronization module (214), to synchronize data to the centralized server (106)at the generated random time interval. The generated random time interval refers to a dynamically calculated time period determined by the system that specifies when data synchronization should occur. This interval is bounded by a minimum threshold of 1 minute and a maximum threshold of 24 hours from the time of generation. The interval incorporates various factors including current network conditions, server load patterns, and historical synchronization success rates to optimize the timing of data transfers. The randomization ensures that multiple devices do not attempt synchronization simultaneously, thereby preventing server overload while maintaining data freshness requirements. The data synchronization module (214) may restrict the synchronization attempts to once per a predetermined time period for any given event. This time period is configurable through system parameters and can be adjusted based on operational requirements, network conditions, and device capabilities. While a default setting of 24 hours is provided, the system administrator can tune this interval within a range of 1 hour to 72 hours to optimize data freshness and system performance. The time period may also be dynamically adjusted based on factors such as network congestion, server load, and battery status of the user equipment. This approach balances the need for up-to-date data with considerations of network usage and device battery life.

[0144] The restriction of synchronization attempts follows a precisely controlled process implemented by the system. When a synchronization event is triggered, the system first consults its synchronization history database to retrieve the timestamp of the last successful synchronization for the specific event type. The system then calculates the elapsed time since the last synchronization by comparing the current timestamp with the stored timestamp. This comparison utilizes a high- precision time measurement system that accounts for time zone differences and daylight-saving transitions. The system maintains separate synchronization counters for each event type, incrementing them only when synchronization is attempted. Before allowing a new synchronization attempt, the system evaluates multiple conditions: it verifies whether the predetermined time period has elapsed, checks if any ongoing synchronization attempts exist for the same event type, and confirms the absence of any system-wide synchronization blocks. The systemimplements a locking mechanism that prevents concurrent synchronization attempts for the same event type, using distributed locks in cases where multiple device instances are involved. If the elapsed time is less than the predetermined period, the system automatically defers the synchronization attempt and logs the deferral reason. The system also maintains a persistent record of all restriction decisions including timestamps, event types, and outcomes to ensure compliance with the synchronization frequency limits and to support system auditing.

[0145] The process of attempting to synchronize the passive data involves several sequential steps executed by the system. Initially, the system checks for an active network connection and sufficient battery level on the user equipment. Upon confirming these prerequisites, the system establishes a secure communication channel with the centralized server using encrypted protocols. The system then prepares the passive data by compressing and packaging it into predetermined formats suitable for transmission. Before initiating the actual data transfer, the system verifies the available network bandwidth and adjusts the data packet sizes accordingly. The system then begins the synchronization by sending data packets to the server while maintaining checksums for verification. During transmission, the system continuously monitors the connection status and data integrity. If any packet fails to transmit properly, the system implements automatic retries for that specific packet while maintaining the overall synchronization state. The system also tracks the progress of synchronization and maintains detailed logs of all transmission attempts and their outcomes.

[0146] At step (506), the method (500) includes retrying synchronization, by the data synchronization module (214), upon occurrence of a next event in response to a failed synchronization attempt. The next event for retry synchronization is defined as an occurrence of the at least one event for capturing passive data. This ensures that valuable data is not lost due to temporary network issues or other short-term problems. The process of retrying synchronization after a failed attempt follows a systematic approach. When a synchronization attempt fails, the system first analyzes and logs the cause of failure, which may include network disconnection, server timeout, data corruption, or insufficient deviceresources. The system then implements a graduated retry mechanism that begins with an immediate verification of the failure cause. If the failure was due to temporary network issues, the system waits for network stability before proceeding. For server-related failures, the system performs a server availability check before initiating a retry. The retry process includes a preparation phase where the system reassembles the data packets that failed to synchronize, verifies their integrity, and reestablishes a secure connection with the server. During the retry, the system implements additional error handling mechanisms including packet-level acknowledgments and progressive data transfer resumption from the last successful checkpoint. The system maintains a retry counter and associated metadata to track multiple retry attempts and their outcomes. If subsequent retries fail, the system progressively increases the wait time between attempts using an exponential backoff algorithm to prevent network congestion. The retry process continues until either successful synchronization is achieved or the next scheduled event occurs. Throughout this process, the system maintains detailed logs of each retry attempt, including timestamps, failure reasons, and the amount of data successfully transferred, which aids in system optimization and troubleshooting.

[0147] At step (508), the method (500) includes transmitting, by the load balancing module (216), successfully synchronized passive data to one of a plurality of servers, wherein the load balancing module (216) randomly redirects the synchronized passive data to the plurality of servers. This random distribution helps ensure that no single server becomes overloaded with synchronized data, thereby maintaining system efficiency and reliability.

[0148] In an embodiment, the method (500) includes processing, by the data processing module (218), the synchronized passive data to convert the synchronized passive data from an unorganized format to an organized format. The unorganized format represents raw data as initially captured from devices, characterized by its non-standardized structure and variable formatting. For example, incoming data might arrive as heterogeneous JSON objects with inconsistent field names and data types: {"dev_id": "ABC123", "sig_str": "-85", "timestamp": "2024-01-21T10:15:30Z", "net_type": "4G"} and {"devicelD":"XYZ789", "signal": -90, "time": 1705831530, "connection": "5G" }. Another example includes semicolon-delimited text files containing mixed data types: "DEV456;2024-01-21 10:15:30;-82dBm; LTE;45%". Binary data streams may also arrive with variable-length records containing packed fields without clear demarcation.

[0149] The organized format represents the standardized, structured data after processing, optimized for efficient storage and querying. The system converts the previous examples into a uniform structure with consistent field naming, data types, and relationships. The system also generates appropriate indexes and partitioning schemes based on common query patterns.

[0150] The continuous synchronized passive data processing operation executes through a multi-threaded streaming engine that maintains constant data flow processing. The system implements this through a pipeline architecture where multiple processing stages operate concurrently. The first stage continuously reads incoming data from the message queue, maintaining a configurable buffer of pending messages. The transformation stage applies schema validation, data type conversion, and field normalization in parallel streams. The system maintains processing state using checkpoints created every 30 seconds, enabling automatic recovery from failures without data loss. Back-pressure mechanisms prevent system overload by dynamically adjusting processing rates based on downstream system capacity. The system scales processing resources automatically when queue depth exceeds predetermined thresholds, adding additional processing threads as needed. Transaction management ensures atomic updates across related data elements, maintaining data consistency throughout the continuous processing cycle.

[0151] This processing may involve executing a streaming job to convert the synchronized passive data, where the streaming job is a continuous synchronized passive data processing operation that operates in real-time as the synchronized passive data is received. The processing of synchronized passive data involves a comprehensive transformation pipeline executed by the system. The process begins with data validation where the system verifies the completeness and integrity of received data packets through checksum verification and formatvalidation. Upon successful validation, the system initiates a multi-stage conversion process. First, the system performs data normalization by standardizing timestamps to UTC format and harmonizing numerical values to consistent units. The system then applies data cleaning algorithms to handle missing values, remove duplicates, and correct any anomalies in the dataset. Following cleaning, the system executes data structuring operations where the unorganized raw data, typically received in semi-structured formats like JSON or binary streams, is parsed and mapped to predefined schema definitions. The system applies data typing rules to ensure proper classification of numeric, textual, and temporal fields. During this conversion, the system maintains referential integrity by generating appropriate indexes and establishing relationships between different data elements. The system then performs data enrichment by adding metadata including processing timestamps, data lineage information, and quality metrics. The final stage involves optimizing the data structure for efficient storage and retrieval by implementing appropriate compression algorithms and creating necessary database indexes. Throughout this process, the system maintains detailed audit logs of all transformations applied to ensure data traceability and compliance with data governance requirements. If any stage of the processing pipeline encounters errors, the system implements automatic error recovery mechanisms while preserving the original data integrity.

[0152] In an embodiment, the method (500) includes storing the processed data in a database (210). The stored processed data may be utilized for analytics and reporting, providing valuable insights into network performance and user behavior.

[0153] In an embodiment, the method (500) may further include storing the synchronized passive data in a distributed streaming platform cluster before processing by the data processing module (218). The distributed streaming platform cluster may comprise a set of servers configured to store and process large streams of the synchronized passive data in real-time. A distributed streaming platform cluster represents a horizontally scalable system architecture that provides fault- tolerant data storage and processing capabilities. The cluster consists of multipleinterconnected server nodes, each running specialized streaming software components. The architecture implements a publisher-subscriber model where data producers write to partitioned topics while consumers read from these topics independently. The platform maintains data replication across multiple nodes to ensure high availability and fault tolerance. Each node in the cluster serves specific roles including broker nodes that handle data routing, controller nodes that manage cluster metadata, and worker nodes that process incoming data streams. The cluster implements a distributed commit log that maintains the complete history of all data modifications, enabling replay and recovery capabilities. The platform utilizes a partitioning strategy that distributes data across nodes based on configurable keys, ensuring balanced data distribution and efficient parallel processing.

[0154] The system handles large streams of data that typically exceed several gigabytes per hour of raw synchronized passive data. For example, in a deployment serving 1 million active devices, each device generating 10KB of data every 15 minutes, the system processes approximately 40GB of data per hour. These streams include diverse data types such as network performance metrics (50 data points per second per device), user interaction events (1000 events per second across all devices), device state changes (100 state changes per second), and system health metrics (25 metrics per second per device). The system implements a multistage processing pipeline that can handle burst traffic up to 100,000 messages per second during peak periods. To process these large streams, the system employs techniques such as micro-batching where incoming data is grouped into 100ms windows for efficient processing, parallel processing across multiple consumer groups with each group handling specific data categories, and adaptive rate limiting that adjusts processing speed based on system load and resource availability.

[0155] Additionally, in an embodiment, the method (500) may include monitoring, by the UE (108), occurrence of the at least one event for capturing passive data and deleting the stored passive data after successful synchronization to the centralized server (106). This helps manage storage space on the UE (108) while ensuring that synchronized data is retained in the system's database. The monitoring process for event occurrence follows a systematic approach implemented by theuser equipment. The system employs a continuous event listener that operates in the background with minimal resource utilization. This listener interfaces with various device subsystems through APIs to detect state changes. When monitoring screen activation events, the system registers with the device's display manager to receive notifications of screen state transitions. For airplane mode monitoring, the system observes radio interface state changes through the telephony manager. The GPS status monitoring utilizes location service callbacks to detect changes in positioning system availability. Network switching detection is accomplished through continuous sampling of the active network interface parameters. The system implements efficient polling mechanisms with adaptive intervals based on device state and battery level, ensuring comprehensive event detection while minimizing power consumption.

[0156] Passive data encompasses various categories of automatically collected information that requires no active user intervention. For example, network-related passive data includes signal strength measurements (e.g., -85 dBm for 4G LTE), connection type transitions (e.g., switching from WiFi to cellular data), and bandwidth utilization patterns (e.g., 2.5 Mbps average throughput). Device-related passive data comprises battery level fluctuations (e.g., discharge rate of 2% per hour), processor utilization metrics (e.g., 15% average CPU usage), and storage availability status. Location-based passive data includes cell tower identifiers (e.g., Cell ID: 12345), GPS accuracy levels (e.g., 5 -meter precision), and movement patterns. Usage-related passive data covers screen activation duration (e.g., active for 45 minutes), application runtime statistics (e.g., 20 minutes of active usage), and connectivity session lengths (e.g., 2 hours of continuous network connection).

[0157] The deletion of stored passive data after successful synchronization follows a secure and verified process. Initially, the system receives a synchronization success acknowledgment from the centralized server, which includes checksums of successfully transferred data blocks. The system then verifies these checksums against local data to ensure complete and accurate synchronization. Upon verification, the system initiates a secure deletion procedurethat begins by identifying all relevant data files and their associated metadata. The system implements a secure erasure protocol that overwrites the data blocks with null values before removing file system references. This process includes deletion of primary data files, temporary storage buffers, and any redundant copies created during the synchronization process. The system maintains deletion logs containing timestamps and verification status while ensuring no sensitive data remnants remain in the device storage.

[0158] In a further exemplary embodiment, a user equipment communicatively coupled to a network is described. The coupling comprises steps of receiving, by the network, a connection request from the UE, sending, by the network, an acknowledgment of the connection request to the UE and transmitting a plurality of signals in response to the connection request. The data synchronization in the network is performed by a method that comprises generating, by a synchronization timing module, a random time interval for data synchronization upon launch of an application on a user equipment (UE). Attempting, by a data synchronization module, to synchronize data to a centralized server at the generated random time interval. Retrying synchronization, by the data synchronization module, upon occurrence of a next event in response to a failed synchronization attempt. Transmitting, by a load balancing module, successfully synchronized data to one of a plurality of servers.

[0159] In yet another exemplary embodiment, the present disclosure discloses a computer program product comprising a non-transitory computer- readable medium comprising instructions that, when executed by one or more processors, cause the one or more processors to perform a method for data synchronization. The method comprises generating, by a synchronization timing module, a random time interval for data synchronization upon launch of an application on a user equipment (UE). Attempting, by a data synchronization module, to synchronize data to a centralized server at the generated random time interval. Retrying synchronization, by the data synchronization module, upon occurrence of a next event in response to a failed synchronization attempt.Transmitting, by a load balancing module, successfully synchronized data to one of a plurality of servers.

[0160] The present disclosure provides technical advancement related to efficient data synchronization in mobile networks. This advancement addresses the limitations of existing solutions by implementing a randomized synchronization approach and load-balancing techniques. The disclosure involves a method for capturing, synchronizing, and processing large volumes of network data, which significantly improves data collection efficiency and server load management. The disclosed invention enhances network performance monitoring and optimization by implementing random time intervals for synchronization and distributed data processing, resulting in improved network quality and user experience.

[0161] FIG. 6 illustrates an example computer system (600) in which or with which the embodiments of the present disclosure may be implemented.

[0162] As shown in FIG. 6, the computer system (600) may include an external storage device (610), a bus (620), a main memory (630), a read-only memory (640), a mass storage device (650), a communication port(s) (660), and a processor (670). A person skilled in the art will appreciate that the computer system (600) may include more than one processor and communication ports. The processor (670) may include various modules associated with embodiments of the present disclosure. The communication port(s) (660) may be any of an RS-232 port for use with a modem-based dialup connection, a 10 / 100 Ethernet port, a Gigabit or 10 Gigabit port using copper or fibre, a serial port, a parallel port, or other existing or future ports. The communication ports(s) (660) may be chosen depending on a network, such as a Local Area Network (LAN), Wide Area Network (WAN), or any network to which the computer system (600) connects.

[0163] In an embodiment, the main memory (630) may be Random Access Memory (RAM), or any other dynamic storage device commonly known in the art. The read-only memory (640) may be any static storage device(s) e.g., but not limited to, a Programmable Read Only Memory (PROM) chip for storing static information e.g., start-up or basic input / output system (BIOS) instructions for the processor (670). The mass storage device (650) may be any current or future massstorage solution, which can be used to store information and / or instructions. Exemplary mass storage solutions include, but are not limited to, Parallel Advanced Technology Attachment (PATA) or Serial Advanced Technology Attachment (SATA) hard disk drives or solid-state drives (internal or external, e.g., having Universal Serial Bus (USB) and / or Firewire interfaces).

[0164] In an embodiment, the bus (620) may communicatively couple the processor(s) (670) with the other memory, storage, and communication blocks. The bus (620) may be, e.g. a Peripheral Component Interconnect PCI) / PCI Extended (PCI-X) bus, Small Computer System Interface (SCSI), Universal Serial Bus (USB), or the like, for connecting expansion cards, drives, and other subsystems as well as other buses, such a front side bus (FSB), which connects the processor (670) to the computer system (600).

[0165] In another embodiment, operator and administrative interfaces, e.g., a display, keyboard, and cursor control device may also be coupled to the bus (620) to support direct operator interaction with the computer system (600). Other operator and administrative interfaces can be provided through network connections connected through the communication port(s) (660). Components described above are meant only to exemplify various possibilities. In no way should the aforementioned exemplary computer system (600) limit the scope of the present disclosure.

[0166] The method and system of the present disclosure may be implemented in a number of ways. For example, the methods and systems of the present disclosure may be implemented by software, hardware, firmware, or any combination of software, hardware, and firmware. The above-described order for the steps of the method is for illustration only, and the steps of the method of the present disclosure are not limited to the order specifically described above unless specifically stated otherwise. Further, in some embodiments, the present disclosure may also be embodied as programs recorded in a recording medium, the programs including machine-readable instructions for implementing the methods according to the present disclosure. Thus, the present disclosure also covers a recordingmedium storing a program for executing the method according to the present disclosure.

[0167] While considerable emphasis has been placed herein on the preferred embodiments, it will be appreciated that many embodiments can be made and that many changes can be made in the preferred embodiments without departing from the principles of the disclosure. These and other changes in the preferred embodiments of the disclosure will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter to be implemented merely as illustrative of the disclosure and not as limitation.ADVANTAGES OF THE PRESENT DISCLOSURE

[0168] The present disclosure provides a technically advanced solution for significant data synchronization with a time randomization application programming interface (API), enhancing the efficiency and reliability of data collection in mobile networks.

[0169] The present disclosure offers an improved system and method that efficiently synchronizes data collected from users and performs data synchronization without any leakage, ensuring data integrity and security.

[0170] The present disclosure introduces an enhanced system and method that maximizes data capturing at the backend servers, enabling comprehensive analysis and reporting of network performance and user behavior.

[0171] The present disclosure implements a novel approach to synchronize data collected from users on a random basis, effectively avoiding server overload and ensuring balanced resource utilization.

[0172] The present disclosure enables the synchronization of significant amounts of data (in millions) in the backend, allowing for large-scale data processing and analysis.

[0173] The present disclosure facilitates the creation of complete user profiles for communication network users, providing valuable insights for network operators and service providers.

[0174] The present disclosure offers a scalable solution that is applicable across multiple generations of mobile technology, including 2G, 3G, 4G, 5G, 6G, and beyond, ensuring long-term relevance and adaptability.

[0175] The present disclosure implements a distributed streaming platform cluster, enabling real-time processing of large data streams and improving overall system performance.

[0176] The present disclosure incorporates a load-balancing mechanism that randomly redirects synchronized data to multiple servers, enhancing system reliability and preventing individual server overload.

[0177] The present disclosure provides an efficient system and method for converting unorganized data into an organized format suitable for analysis, streamlining the data processing pipeline.

[0178] The present disclosure offers a solution that optimizes device resource usage by implementing event-based data capture and synchronization, balancing data collection needs with device performance considerations.

Claims

We claim:

1. A system (102) for data synchronization, the system (102) comprising: a memory (204); one or more processors (202) coupled to the memory (204), the one or more processors (202) configured to execute a set of instructions stored in the memory (204) to: generate, by a synchronization timing module (212), a random time interval for data synchronization upon launch of an application on a user equipment (UE) (108); attempt, by a data synchronization module (214), to synchronize data to a centralized server (106) at the generated random time interval; retry synchronization, by the data synchronization module (214), upon occurrence of a next event in response to a failed synchronization attempt; and transmit, by a load balancing module (216), successfully synchronized data to one of a plurality of servers.

2. The system (102) as claimed in claim 1, wherein the UE (108) is configured to capture and store data comprising network and signal key performance indicators (KPIs) upon occurrence of at least one event from a predefined set of events.

3. The system (102) as claimed in claim 1, wherein the network and signal KPIs comprise at least one of: signal strength, network type, data transfer rate, latency, packet loss, network availability, network coverage, network congestion, and network switching frequency.

4. The system (102) as claimed in claim 1, wherein the load balancing module (216) randomly redirects the synchronized data to the plurality of servers.

5. The system (102) as claimed in claim 1, wherein the data synchronization module (214) is configured to restrict the synchronization attempts to once per a predetermined time period for any given event.

6. The system (102) as claimed in claim 1, wherein the one or more processors (202) further configured to process the synchronized data to convert the synchronized data from an unorganized format to an organized format; and to store the processed synchronized data in a database (210).

7. The system (102) as claimed in claim 1, wherein the next event for retry synchronization is defined as an occurrence of the at least one event for capturing the data.

8. A method (500) for data synchronization, the method (500) comprising: generating (502), by a synchronization timing module (212), a random time interval for data synchronization upon launch of an application on a user equipment (UE) (108); attempting (504), by a data synchronization module (214), to synchronize data to a centralized server (106) at the generated random time interval; retrying (506) synchronization, by the data synchronization module (214), upon occurrence of a next event in response to a failed synchronization attempt; and transmitting (508), by a load balancing module (216), successfully synchronized data to one of a plurality of servers.

9. The method (500) as claimed in claim 8, wherein the UE (108) is configured to capture and store data comprising network and signal key performance indicators (KPIs) upon occurrence of at least one event from a predefined set of events.

10. The method (500) as claimed in claim 8, wherein the network and signal KPIs comprise at least one of: signal strength, network type, data transfer rate, latency, packet loss, network availability, network coverage, network congestion, and network switching frequency.

11. The method (500) as claimed in claim 8, wherein the load balancing module (216) randomly redirects the synchronized data to the plurality of servers.

12. The method (500) as claimed in claim 8, further comprising restricting, by the data synchronization module (214), the synchronization attempts to once per a predetermined time period for any given event.

13. The method (500) as claimed in claim 8, further comprising processing, by a data processing module (218), the synchronized data to convert the synchronized data from an unorganized format to an organized format; and storing the processed synchronized data in a database (210).

14. The method (500) as claimed in claim 8, wherein the next event for retry synchronization is defined as an occurrence of the at least one event for capturing the data.

15. A user equipment (UE) (108) communicatively coupled to a network (104), the coupling comprises steps of: receiving, by the network (104), a connection request from the UE (108); sending, by the network (104), an acknowledgment of the connection request to the UE (108); and transmitting a plurality of signals in response to the connection request, wherein data synchronization in the network (104) is performed by a method (500) as claimed in claim 8.

16. A computer program product comprising a non- transitory computer- readable medium storing instructions that, when executed by one or more processors (202), cause the one or more processors (202) to perform a method (500) for data synchronization, the method (500) comprising: generating (502), by a synchronization timing module (212), a random time interval for data synchronization upon launch of an application on a user equipment (UE) (108); attempting (504), by a data synchronization module (214), to synchronize data to a centralized server (106) at the generated random time interval; retrying (506) synchronization, by the data synchronization module (214), upon occurrence of a next event in response to a failed synchronization attempt; and transmitting (508), by a load balancing module (216), successfully synchronized data to one of a plurality of servers.

Images