Synchronous actions

Abstract

An apparatus (100) comprising a display screen (104) and a processor (112) is disclosed. The processor is configured to generate a graphical user interface (102, 304) and display the graphical user interface (102, 304) on the display screen, receive a user request (202) to perform a requesting action (210) on the graphical user interface, send the user request to a server (204, 308), perform an intermediate action (206) on the graphical user interface while waiting the server to create and provide instructions related to the user request, and transmit the instructions to the server (204, 308). Instructions related to the user request are received from the server (208), execution of the intermediate action is terminated, and the received instructions related to the user request are executed on the graphical user interface. A system including a server communicatively coupled to a plurality of devices that collaborate via respective graphical user interfaces is also disclosed.

Description

Technical Field

[0001] The present disclosure relates to a device including a display screen and a processor. The present disclosure also relates to a system for synchronizing actions, the system including a server communicatively coupled to a plurality of devices. The present disclosure also relates to a computer-implemented method for synchronizing actions. Background Art

[0002] In recent years, the use of electronic devices such as smart phones, tablet computers, laptops, etc., for daily activities including but not limited to making phone calls, exchanging messages, browsing the Internet, navigation, and media consumption has increased exponentially. Today, electronic devices are also widely used to play games (such as single-user games or multi-user games), render and edit images or videos by one or more users using a common interface, simulation, etc. Most of these electronic devices incorporate a touch-sensitive display screen, and any application implemented on the electronic device can be controlled by touch-sensitive operations on such a display screen. An important aspect of any application implemented on an electronic device is that the user can easily interact with the user interface of the application to control its various operations.

[0003] In particular, for a better user experience, applications are intended to render user interfaces seamlessly, free from jitter, delay or lag. However, when giving commands to applications (such as, client-server applications), during the interaction, the application interacts with the server, and the user experiences jitter, delay or lag caused by the network delay between the server and the electronic device and the processing time spent by the server and / or the electronic device itself to process the command on her / his electronic device. As a result, the command given by the user on the user interface does not start executing immediately at the initiation of the command, but starts executing at another time, which is a function of the delay caused by communication and processing. In fact, the user may provide the same command many times, resulting in an increased number of commands, thereby further increasing the unnecessary communication between the application and the server and the delay associated therewith, thus resulting in a poor user experience.

[0004] In addition, when two or more users control their corresponding user interfaces in an application, different users may face different hysteresis problems, resulting in a bad user experience when each user performs related actions and wants to synchronize their actions. For example, a first user can perform a first action related to an object at a specific moment, and a second user can perform a second action on the same object at a later moment. However, due to different hysteresis, the execution of the second action is made visible in the user interface for the second user before the first action is completed by the first user. Therefore, different delays may lead to situations when those actions contradict each other and are even impossible. One of the conventional techniques available is to collect commands from two or more users in a server, and then provide instructions to the processor of the electronic device simultaneously according to the command. However, hysteresis is still perceived on the electronic device; as a result, the user interface of the electronic device is not properly synchronized.

[0005] Therefore, in view of the foregoing discussion, a need exists to overcome the above-mentioned shortcomings associated with conventional systems. Summary of the invention

[0006] The present disclosure is directed to a device comprising a display screen and a processor. The present disclosure is also directed to a system for synchronizing actions, comprising a server communicatively coupled to a plurality of devices. The present disclosure is also directed to a computer-implemented method for synchronizing actions. The goal of the present disclosure is to provide a solution that at least partially overcomes the problems encountered in the prior art.

[0007] In a first aspect, an embodiment of the present disclosure provides a device, the device comprising:

[0008] Display screen; and

[0009] A processor configured to:

[0010] - generating a graphical user interface and displaying the graphical user interface on a display screen;

[0011] - receiving a user request to perform a requested action on a graphical user interface;

[0012] - Send user request to the server;

[0013] -Performing intermediate actions on the graphical user interface while waiting for the server to create and provide instructions related to the user request;

[0014] - receiving instructions from the server related to the user's request;

[0015] - terminate execution of the intermediate action; and

[0016] -Executing received instructions related to the user request on the graphical user interface.

[0017] In a second aspect, an embodiment of the present disclosure provides a system, comprising a server communicatively coupled to a plurality of devices according to the first aspect, wherein the plurality of devices cooperate via corresponding graphical user interfaces, and the server is configured to:

[0018] receiving corresponding user requests from a plurality of devices to perform corresponding requested actions on corresponding graphical user interfaces;

[0019] - collecting from among the received user requests a given set of user requests which have been received during a given time interval;

[0020] - processing a given set of user requests to create corresponding instructions related to the given set of user requests, wherein when processing the given set of user requests, the server is configured to determine a time period within which the corresponding request action is to be performed based on different network delays between the server and the respective devices, and wherein the corresponding instructions indicate to the respective devices the determined time period within which the corresponding request action is to be performed; and

[0021] - Sending corresponding instructions related to a given set of user requests to multiple devices.

[0022] In a third aspect, an embodiment of the present disclosure provides a computer-implemented method, the computer-implemented method comprising:

[0023] - generating a graphical user interface and displaying the graphical user interface on a display screen of the device;

[0024] - receiving a user request to perform a requested action on a graphical user interface;

[0025] - Send user request to the server;

[0026] -Performing intermediate actions on the graphical user interface while waiting for the server to create and provide instructions related to the user request;

[0027] - receiving instructions from the server related to the user's request;

[0028] - terminate execution of the intermediate action; and

[0029] -Executing received instructions related to the user request on the graphical user interface.

[0030] In a fourth aspect, an embodiment of the present disclosure provides a computer program product comprising a non-transitory computer-readable storage medium having computer-readable instructions stored thereon, which are executable by a computing device comprising a processor to perform a method according to the third aspect above.

[0031] The embodiments of the present disclosure substantially eliminate or at least partially solve the above-mentioned problems in the prior art, and enable a graphical user interface to be rendered on a device so that a user does not experience any jitter or lag in the execution of actions when interacting with the user interface of an application to control its various operations.

[0032] Additional aspects, advantages, features, and objects of the present disclosure will become apparent from the accompanying drawings and detailed description of exemplary embodiments, which are interpreted in conjunction with the appended claims.

[0033] It will be appreciated that features of the present disclosure are susceptible to being combined in various combinations without departing from the scope of the present disclosure as defined by the appended claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] When read in conjunction with the accompanying drawings, the above-mentioned invention content and the specific implementation of the following exemplary embodiments will be better understood. For the purpose of illustrating the present disclosure, exemplary configurations of the present disclosure are shown in the accompanying drawings. However, the present disclosure is not limited to the specific methods and means disclosed herein. Moreover, those skilled in the art will understand that the drawings are not to scale. As much as possible, the same elements are indicated by the same numbers.

[0035] Embodiments of the present disclosure will now be described, by way of example only, with reference to the following drawings, in which:

[0036] Figure 1 is a schematic illustration of an apparatus for rendering a graphical user interface according to an embodiment of the present disclosure;

[0037] Figure 2 is a schematic illustration of a timeline associated with processing of a user request according to an embodiment of the present disclosure;

[0038] Figure 3 is a schematic illustration of steps depicting movement of a user-controllable object on a graphical user interface according to an embodiment of the present disclosure; and

[0039] Figure 4A and Figure 4B Each is a flow chart depicting steps of a computer-implemented method for synchronizing actions according to an embodiment of the present disclosure.

[0040] In the accompanying drawings, underlined numbers are used to indicate the item on which the underlined number is located or the item to which the underlined number is adjacent. Non-underlined numbers are associated with the item identified by the line linking the non-underlined number to the item. When a number is non-underlined and is accompanied by an associated arrow, the non-underlined number is used to identify the general item to which the arrow points. DETAILED DESCRIPTION

[0041] The following detailed description describes embodiments of the present disclosure and ways to implement them. Although some modes of implementing the present disclosure have been disclosed, it will be appreciated by those skilled in the art that other embodiments for implementing or practicing the present disclosure are also possible.

[0042] In a first aspect, an embodiment of the present disclosure provides a device, the device comprising:

[0043] Display screen; and

[0044] A processor configured to:

[0045] - generating a graphical user interface and displaying the graphical user interface on a display screen;

[0046] - receiving a user request to perform a requested action on a graphical user interface;

[0047] - Send user request to the server;

[0048] -Performing intermediate actions on the graphical user interface while waiting for the server to create and provide instructions related to the user request;

[0049] - receiving instructions from the server related to the user's request;

[0050] - terminate execution of the intermediate action; and

[0051] -Executing received instructions related to the user request on the graphical user interface.

[0052] In a second aspect, an embodiment of the present disclosure provides a system, comprising a server communicatively coupled to a plurality of devices according to the first aspect, wherein the plurality of devices cooperate via corresponding graphical user interfaces, and the server is configured to:

[0053] receiving corresponding user requests from a plurality of devices to perform corresponding requested actions on corresponding graphical user interfaces;

[0054] - collecting from among the received user requests a given set of user requests which have been received during a given time interval;

[0055] - processing a given set of user requests to create corresponding instructions related to the given set of user requests, wherein when processing the given set of user requests, the server is configured to determine a time period within which the corresponding request action is to be performed based on different network delays between the server and the respective devices, and wherein the corresponding instructions indicate to the respective devices the determined time period within which the corresponding request action is to be performed; and

[0056] - Sending corresponding instructions related to a given set of user requests to multiple devices.

[0057] In a third aspect, an embodiment of the present disclosure provides a computer-implemented method, the computer-implemented method comprising:

[0058] - generating a graphical user interface and displaying the graphical user interface on a display screen of the device;

[0059] - receiving a user request to perform a requested action on a graphical user interface;

[0060] - Send user request to the server;

[0061] -Performing intermediate actions on the graphical user interface while waiting for the server to create and provide instructions related to the user request;

[0062] - receiving instructions from the server related to the user's request;

[0063] - terminate execution of the intermediate action; and

[0064] -Executing received instructions related to the user request on the graphical user interface.

[0065] In a fourth aspect, an embodiment of the present disclosure provides a computer program product comprising a non-transitory computer-readable storage medium having computer-readable instructions stored thereon, which are executable by a computing device comprising a processor to perform a method according to the third aspect above.

[0066] The present disclosure provides the above-mentioned device, the above-mentioned system and the method implemented by the above-mentioned computer. The embodiment of the present disclosure provides a graphical user interface without jitter and lag to provide a better experience to the user. In this regard, during the processing of the user request by the server, the execution of the intermediate action on the graphical user interface is controlled locally. Beneficially, the intermediate action is provided on the graphical user interface immediately after the user request is received, so that the intermediate action serves as feedback to the ongoing user request. This provides better usability to the user. Moreover, the user requests received from multiple devices during a given time interval are also processed by the server at one time to avoid any contradictory actions to be executed. Since the corresponding instructions indicate the determined time period to each device, the corresponding request action will be executed within the time period, so the allowed request action is executed in a synchronized manner at multiple devices. This enables users to experience synchronized actions even when their devices experience different network delays.

[0067] Throughout this disclosure, the term "device" as used herein refers to an electronic device associated with a user (i.e., used by a user) that enables the user to perform a specific task. The user can be any entity associated with or operating the device, such as a person (i.e., a human) or a virtual program (such as an autonomous program or a robot). It is noteworthy that the device is a user device. Examples of devices may include, but are not limited to, cellular phones, personal digital assistants (PDAs), handheld devices, laptop computers, personal computers, etc. configured to provide a graphical user interface on their display screens. Beneficially, the interaction between the user and the device allows efficient operation and control therebetween.

[0068] As used herein, the term "graphical user interface" refers to the space in which the interaction between a user and a device occurs. Typically, a graphical user interface presents one or more spatially distributed elements. It should be understood that a graphical user interface allows a user to manipulate elements presented on a display screen using a mouse, a stylus, or by fingers. Beneficially, a graphical user interface is designed to allow a user to interact with a device easily, efficiently, and in a user-friendly manner to provide maximum usability thereof.

[0069] The term "display screen" as used herein refers to a screen of a device. Typically, a display screen is configured to provide visual graphics of a graphical user interface to a user.

[0070] The term "processor" as used herein refers to a computing element that is operable to respond to and process instructions given by a user and is operable to control the operation of a device. Examples of processors include, but are not limited to, a microprocessor, a microcontroller, a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or any other type of processing circuit. In addition, a processor may refer to one or more separate processors, processing devices, and various elements associated with a processing device that may be shared by other processing devices.

[0071] The term "server" as used herein refers to a powerful physical infrastructure or virtual infrastructure that has been virtualized to perform application and information processing, storage and enable users to access stored information remotely over a data communication network. The server includes suitable logic, circuits, interfaces and / or codes that are configured to store, process and / or receive information corresponding to a request action from a device. Moreover, the server is configured to provide real-time instructions based on the request action. It should be understood that the server can be a cloud server. In addition, the server can be a single server, or multiple servers operating in a parallel architecture or a distributed architecture to be operably coupled to the disclosed device or similar system. Examples of servers include, but are not limited to, storage servers, web servers, application servers, or combinations thereof.

[0072] As used herein, the term "user request" refers to a command provided by a user. Such a command may be provided via any suitable input, such as, for example, a touch input (when the display screen is a touch screen), a mouse click, or the like. A user request includes information corresponding to a requested action to be performed on a graphical user interface. Moreover, a command may, for example, be provided as a word, a phrase, or a sentence to cause a change in a graphical user interface, etc. For example, a user request may be provided by tapping on a touch screen to move to a target location.

[0073] Optionally, the user request is timestamped. It is noteworthy that the time at which the user request is received from the user is recorded at the device. In this regard, the server has information about the time at which the user creates the user request. Moreover, the timestamp of the user request enables the processor to identify the time at which the intermediate action is initiated, and optionally identifies the time from which the time period is calculated, during which the request action is performed when the instruction is received from the server. For example, the server can receive a timestamp of the time (t0) together with the user request, at which the user request is received at the device. After processing the user request, the server can provide a time period, during which the user request is executed, wherein the time period starts at time (t0). Since the timestamp of time (t0) is available for the server, the server can alternatively provide an end time (t2), and the time period ends at the end time (t2). Therefore, the instruction can indicate the time period by providing the end time of the time period or the time period. Beneficially, the timestamp also eliminates the problem of variable delay in the device because it allows the server to collect the user requests received at a given time interval.

[0074] The term "intermediate action" as used herein refers to an action that occurs between the time when a user request is received and the following time, at which an instruction is received from a server or processed by a processor to perform a request action on a graphical user interface. Typically, the intermediate action is performed immediately after receiving the user request. Additionally, even when there is a network delay and / or processing delay, the intermediate action provides the illusion that the action is performed in the graphical user interface. As a result, the user does not need to repeat sending the user request unnecessarily many times, because the user can see the intermediate action that occurs immediately after providing the user request. Moreover, during the execution of the intermediate action, the server processes the user request for the request action and generates an instruction to be provided to the processor. In addition, when the processor processes or executes the instruction corresponding to the request action received from the server on the graphical user interface, the termination of the intermediate action occurs. When the server determines that the request action is permissible, the received instruction from the server causes the request action to be performed on the graphical user interface. Otherwise, when the server determines that the requested action is not permissible, executing the received instruction from the server may result in: undoing the intermediate action (e.g., where the intermediate action is to slowly move the user-controllable object toward the target location and the user-controllable object was already halfway toward the target before the instruction from the server was received), and / or indicating to the user that the requested action is not possible. Optionally, the time difference between receiving the user request and executing the intermediate action is less than a predefined duration. The predefined duration may be, for example, 0.5 seconds, 0.4 seconds, 0.3 seconds, 0.2 seconds, 0.1 seconds, or 0.01 seconds. This ensures that the intermediate action occurs before the user notices any delay.

[0075] Optionally, the request action comprises repositioning at least one user-controllable object from a given position to a target position on the graphical user interface, and the intermediate action comprises at least one of the following:

[0076] - presenting a visual indicator on the graphical user interface to indicate that repositioning of at least one user-controllable object is in progress,

[0077] - showing on the graphical user interface the movement of at least one user-controllable object from a given position towards a target position.

[0078] In this regard, it should be understood that the request action includes instructions for repositioning at least one user-controllable object from a given position to a target position on the graphical user interface. The given position is the position at which the user-controllable object is located when the user request is received. It is worth noting that the given position is the starting point of the user-controllable object and the target position is the end point of the user-controllable object.

[0079] In this article, the term "user controllable object" used herein refers to a symbol that can be controlled by a user and is presented on a graphical user interface. The symbol can, for example, represent a character. As an example, a user controllable object can be a visual (or, graphic) representation of a character generated by an application controlled by a user. In this regard, a user controllable object indicates the real-time position and movement of a character on a graphical user interface (e.g., in a real-time game, navigation, simulator, etc.). Optionally, a user controllable object can have geographic coordinates associated therewith. Additionally, a user controllable object also enables a user to locate other users (such as, in a multiplayer video game). Optionally, a user controllable object can be a pointer, an avatar, or an animated character.

[0080] In this article, the intermediate action includes providing a visual indicator on the graphical user interface to indicate to the user that the repositioning of the at least one user-controllable object is in progress. Optionally, the visual indicator can be text, a symbol or an image. For example, the visual indicator can be an arrow falling from the upper part of the graphical user interface toward the target position. Optionally, the intermediate action includes showing the movement of the at least one user-controllable object from a given position toward the target position on the graphical user interface.

[0081] Optionally, the processor is configured to:

[0082] - determining a speed at which at least one user-controllable object is to be moved based on a distance between a given location and a target location and optionally based on at least one of: a network delay between the device and a server, a processing delay at the server, a processing delay at the device; and

[0083] - while performing the intermediate action, moving at least one user-controllable object from a given position towards a target position at the determined speed.

[0084] It should be understood that the processor is configured to determine the distance between the given position and the target position. Based on the determined distance, the processor calculates an appropriate speed for moving at least one user-controllable object. In addition, the processor determines a network delay between the device and the server and / or a processing delay between the server and the device. It is worth noting that the network delay is caused by the time delay of the data propagated across the data communication network between the device and the server. Optionally, the network delay can be an average delay. Moreover, the processing delay is caused by the time it takes for the server and / or processor of the device to process the user request and the received instruction, respectively.

[0085] Optionally, the received instruction indicates a time period within which at least one user-controllable object is to reach the target location, wherein the time period begins at a start time (t0) at which the processor receives the user request, and wherein the processor is configured to:

[0086] - adjusting the speed based on a time period and a distance between the target location and the current location of the at least one user-controllable object on the graphical user interface, within which the at least one user-controllable object will reach the target location; and

[0087] - upon executing the received instructions, moving at least one user-controllable object towards a target position at an adjusted speed.

[0088] In this regard, the time period is the time taken by the user-controllable object to reach a target location from a given location.Herein, the processor is configured to increase or decrease the speed of the user-controllable object based on the time period and the remaining distance between the target location and the current location.

[0089] For the purpose of illustration, an example will now be considered. At time t0, a user request is provided to move a user-controllable object from a first position (such as a given position) to a second position (such as a target position) on a graphical user interface, from coordinates (first position 100, 200) to coordinates (second position 300, 800), where the numbers refer to the number of pixels from the upper left corner of the graphical user interface in the X and Y directions, respectively. The execution of the intermediate action can start at time t1, indicating that the user-controllable object is moved toward the second position at a first speed. At time t2, the server receives the user request and begins to process the user request. After processing the user request at the server, the instruction is delivered to the device from the server at time t3. The instruction can indicate to the processor that the user request is completed before time t4. It is worth noting that the time period is the time spent from t0 to t4, and the request action will be executed during this time period. At the device, the execution of the intermediate action is terminated when the instruction is received or processed. Then the instruction is executed before time t4. In addition, if the user-controllable object cannot reach the target position within the time period when using the first speed, the speed can be increased. Alternatively, if the user-controllable object can reach the target position earlier, the speed of the user-controllable object can be reduced.

[0090] Optionally, the intermediate action comprises presenting only a visual indicator on the graphical user interface, and the received instruction indicates a time period within which the at least one user-controllable object will reach the target location, wherein the time period begins at a start time (t0) at which the user request is received by the processor, wherein the processor is configured to:

[0091] - determining a speed at which the at least one user-controllable object is to be moved based on a distance between the given location and a target location and a time period within which the at least one user-controllable object is to reach the target location; and

[0092] - upon executing the received instruction, moving at least one user-controllable object from a given position towards a target position at a determined speed.

[0093] The visual indicator is advantageously timed to be presented within a time period that is no shorter than the delay in communicating the requested action to the server. It will be appreciated that the processor is configured to determine the distance between the given location and the target location, and based on the determined distance and the time period indicated in the received instruction, the processor controls the speed of the user-controllable object.

[0094] Optionally, the processor is configured to determine a time period during which the intermediate action will be performed based on at least one of: a network delay between the device and the server, a processing delay at the server, a processing delay at the device, wherein the execution of the intermediate action is terminated after completion of the determined time period. The term "time period" as used herein refers to a duration during which the intermediate action will be performed. In this article, the time period during which the intermediate action will be performed is less than the time period during which at least one user-controllable object will reach a target location. Beneficially, the time period enables the processor to perform the intermediate action so that the user does not experience any jitter or lag in the graphical user interface.

[0095] Optionally, execution of an intermediate action is terminated when at least one of the following occurs:

[0096] - the receipt of instructions related to user requests,

[0097] - Processing of instructions related to user requests, said processing being performed prior to the execution of the instructions.

[0098] It will be appreciated that beneficially, termination of the intermediary action is performed prior to execution of the received instruction, such that the intermediary action and the requested action are not executed simultaneously.

[0099] The present disclosure also relates to a system as described above. The various embodiments and variations disclosed above apply mutatis mutandis to the system.

[0100] It should be understood that multiple devices, multiple corresponding graphical user interfaces, multiple user requests and multiple request actions are used only in the plural form corresponding to the above-mentioned devices, graphical user interfaces, user requests and request actions of the first aspect respectively. In this article, multiple devices can use the same software application to collaborate. Examples of such software applications include, but are not limited to, multi-player games, multi-user simulators, multi-user design software, multi-user text editing software, etc.

[0101] The term "time interval" as used herein refers to a time period during which a set of user requests is collected from received user requests before it is processed to create corresponding instructions. It is noteworthy that the server is configured to process the set of user requests simultaneously. Moreover, the server is also configured to resolve conflicts between the user requests of the set so that there are no contradictions between the request actions. It should be understood that the request actions associated with the set of user requests are executed at different times because they are instructed to be executed within the same time period, but starting from different start times when the corresponding user requests are received at multiple devices. Beneficially, the execution allows the graphical user interface to be synchronized because the device experiencing the smallest network delay does not have an advantage over other devices experiencing larger network delays.

[0102] For illustration purposes only, an example will now be described in which a first user and a second user collaborate together (via a first device and a second device, respectively) using the same software at the same time. A first network delay between the first device and the server is higher than a second network delay between the second device and the server. The first user's device and the second user's device have their own timers, i.e., internal clocks, through which corresponding user requests are received and timestamped.

[0103] At time t0=0 seconds and time t0'=0.1 seconds, corresponding user requests are received at the first device and the second device, respectively. At the server, corresponding user requests are received from the first device and the second device at time t2=0.5 seconds and time t2'=0.2 seconds, respectively. The server collects and processes the user requests to create corresponding instructions for the first device and the second device, wherein the corresponding instructions instruct the first device and the second device to perform corresponding requested actions within a given time period from time t0 and time t0', respectively. As an example, the instruction to the first device may be to perform the requested action at time t0+1.0 seconds, while the instruction to the second device may be to perform the requested action at time t0'+1.0 seconds. In this way, the second user of the second device does not have an advantage over the first user of the first device due to the shorter network delay. Moreover, in order to maintain fluidity in the user interface, intermediate actions are performed while waiting for instructions from the server.

[0104] Optionally, the server is configured to determine a given time interval that the server will wait to collect a given set of user requests based on different network delays between the server and various devices. In this regard, the server is also configured to determine the network delay between the server and various devices. In addition, based on the network delay, the time period for performing the intermediate action can also change.

[0105] Optionally, the server is configured to adjust the given time interval based on fluctuations in network delay. Thus, when the network delay is small, the given time interval can be adjusted to be short. As a result, user requests are collected and processed without any perceptible delay for the user.

[0106] The present disclosure also relates to a computer-implemented method as described above. The various embodiments and variations disclosed above are applicable mutatis mutandis to the computer-implemented method.

[0107] Optionally, the request action comprises repositioning at least one user-controllable object from a given position to a target position on the graphical user interface, and the intermediate action comprises at least one of the following:

[0108] - presenting a visual indicator on the graphical user interface to indicate that repositioning of at least one user-controllable object is in progress,

[0109] - showing on the graphical user interface the movement of at least one user-controllable object from a given position towards a target position.

[0110] Optionally, in some embodiments, the method further comprises determining a speed at which the at least one user-controllable object is to be moved based on a distance between the given location and the target location and optionally based on at least one of: a network delay between the device and the server, a processing delay at the server, a processing delay at the device,

[0111] The step of performing the intermediate action comprises moving at least one user-controllable object from a given position towards a target position at a determined speed.

[0112] Optionally in this regard, the received instruction indicates a time period within which the at least one user-controllable object will reach the target location, wherein the time period begins at a start time (t0) at which the user request is received, and wherein the method includes: adjusting the speed based on the time period and a distance between the target location and a current location of the at least one user-controllable object on the graphical user interface within which the at least one user-controllable object will reach the target location,

[0113] The step of executing the received instructions includes moving at least one user-controllable object toward a target location at an adjusted speed.

[0114] Optionally, in other embodiments, the intermediate action includes presenting only a visual indicator on the graphical user interface, and the received instruction indicates a time period within which the at least one user-controllable object will reach the target location, wherein the time period begins at a start time (t0) at which the user request is received, wherein the method includes: determining a speed at which the at least one user-controllable object will be moved based on a distance between the given location and the target location and the time period, within which the at least one user-controllable object will reach the target location,

[0115] The step of executing the received instruction includes moving at least one user-controllable object from a given position toward a target position at a determined speed.

[0116] Moreover, optionally, the method includes: determining a time period in which the intermediate action will be executed based on at least one of: network delay between the device and the server, processing delay at the server, processing delay at the device, wherein execution of the intermediate action is terminated after completion of the determined time period.

[0117] Optionally, execution of an intermediate action is terminated when at least one of the following occurs:

[0118] - the receipt of instructions related to user requests,

[0119] - Processing of instructions related to user requests, said processing being performed prior to the execution of the instructions.

[0120] Optionally, the method further comprises time stamping the user request.

[0121] Optionally, the method further comprises:

[0122] receiving, at a server, respective user requests from a plurality of devices to perform respective requested actions on respective graphical user interfaces, wherein the plurality of devices collaborate via respective graphical user interfaces;

[0123] - collecting at the server from among the received user requests a given set of user requests that have been received during a given time interval;

[0124] - processing a given set of user requests at the server to create corresponding instructions related to the given set of user requests, wherein the step of processing the given set of user requests includes determining a time period within which the corresponding request action is to be performed based on different network delays between the server and the respective devices, and wherein the corresponding instructions indicate to the respective devices the determined time period within which the corresponding request action is to be performed; and

[0125] - Sending corresponding instructions from the server to the plurality of devices in relation to a given set of user requests.

[0126] The present disclosure also relates to a computer program product as described above. The various embodiments and variants disclosed above are applicable mutatis mutandis to a computer program product.

[0127] Optionally, the computer program product is implemented as an algorithm embedded in software stored in a non-transitory computer-readable storage medium. The non-transitory computer-readable storage medium may include, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. Examples of implementations of computer-readable storage media are, but are not limited to, electrically erasable programmable read-only memory (EEPROM), random access memory (RAM), read-only memory (ROM), hard disk drive (HDD), flash memory, secure digital (SD) card, solid-state drive (SSD), computer-readable storage medium, and / or CPU cache memory.

[0128] Detailed description of the drawings

[0129] refer to Figure 1 , illustrated is a device 100 for rendering a graphical user interface 102 according to an embodiment of the present disclosure. As shown, the graphical user interface 102 is rendered on a display screen 104 of the device 100. The graphical user interface 102 presents an object 106 and at least one user-controllable object 108. The user can control the movement of the user-controllable object 108 on the graphical user interface 102 of the device 100. As an example, a user request to move the user-controllable object 108 can be provided on the graphical user interface by providing a tap at a target location 110 on the graphical user interface 102. As an implementation, the user request is communicated to a server via a processor 112 of the device 100, wherein the user request is verified by the server, and instructions for the movement are provided back to the device 100. At this point, the instructions are executed by the processor 112 of the device 100, and the user-controllable object 108 is moved from a given position 114 to the tapped position (herein, the target position 110).

[0130] refer to Figure 2 , illustrated is a timeline 200 associated with processing of a user request 202 according to an embodiment of the present disclosure. As shown, a user controlling a user interface provides a user request 202 at time t0 to perform a requested action. The user request 202 is communicated to a server 204. The user request 202 is received by the server 204 at time t2. The user request 202 given at time t0 triggers an intermediate action 206. The intermediate action 206 begins at time t1 shortly after time t0 but before time t2.

[0131] At time t3, instructions 208 are received from the server. Furthermore, intermediate actions 206 may be performed until the instructions are received or processed by a processor of the device. Furthermore, instructions 208 are executed at time t4 to perform request actions 210.

[0132] refer to Figure 3 , illustrated is a schematic illustration of steps 300 depicting movement of a user-controllable object 302 in a graphical user interface 304 according to an embodiment of the present disclosure. As shown, moments are depicted as t0, t1, t2, t3, and t4. At time t0, a user request to move the user-controllable object 302 to a target location 306 is received. At time t2, the user request is received by a server 308. At time t1, an intermediate action is performed using a processor of the device. The intermediate action is rendered by moving a visual indicator 310 in the graphical user interface 304 of the device. As shown, the visual indicator 310 is an arrow falling from the upper portion of the graphical user interface 304 toward the target location 306. Optionally, the visual indicator 310 is configured to touch down at time t3, i.e., at the same time that an instruction based on the requested action in the server 308 is received by the processor. During a time period t3-time period t4, the user-controllable object 302 moves (indicated by a dashed line) to the target location 306 at a speed v1.

[0133] refer to Figure 4A and Figure 4B , illustrated is a flowchart 400 of the steps of a computer-implemented method according to an embodiment of the present disclosure. At step 402, a graphical user interface is generated and displayed on a display screen of a device. At step 404, a user request is received to perform a requested action on the graphical user interface. At step 406, the user request is sent to a server. At step 408, an intermediate action is performed on the graphical user interface while waiting for the server to create and provide instructions related to the user request. At step 410, instructions related to the user request are received from the server. At step 412, execution of the intermediate action is terminated. At step 414, the received instructions related to the user request are executed on the graphical user interface.

[0134] Step 402, step 404, step 406, step 408, step 410, step 412, and step 414 are merely exemplary, and other alternatives may be provided without departing from the scope of the claims herein, in which one or more steps are added, one or more steps are removed, or one or more steps are provided in a different order.

[0135] Variations of the embodiments of the present disclosure described in the foregoing are possible without departing from the scope of the present disclosure as defined by the appended claims. Expressions such as "comprises," "includes," "incorporates," "has," "is," used to describe and claim the present disclosure are intended to be interpreted in a non-exclusive manner, i.e., allowing for items, components or elements that are not explicitly described to also be present. References to the singular are also interpreted as relating to the plural.

Claims

1. A device (100), comprising: Display screen (104); as well as A processor (112), the processor being configured to: generating a graphical user interface (102, 304) and displaying the graphical user interface (102, 304) on the display screen; receiving a user request (202) to perform a requested action (210) on the graphical user interface; Sending the user request to a server (204, 308); performing an intermediate action (206) on the graphical user interface while waiting for the server to create and provide instructions related to the user request; receiving the instruction related to the user request from the server (208); terminating the execution of the intermediate action; as well as The received instructions related to the user request are executed on the graphical user interface.

2. The apparatus (100) of claim 1, wherein the requested action (210) comprises repositioning at least one user-controllable object (108, 302) from a given position (114) to a target position (110, 306) on the graphical user interface (102, 304), and the intermediate action (206) comprises at least one of the following: presenting a visual indicator (310) on the graphical user interface to indicate that repositioning of the at least one user-controllable object is in progress, Movement of the at least one user-controllable object from the given position toward the target position is shown on the graphical user interface.

3. The apparatus (100) of claim 2, wherein the processor (112) is configured to: determining a speed at which the at least one user-controllable object (108, 302) is to be moved based on a distance between the given location (114) and the target location (110, 306), and optionally based on at least one of: a network delay between the device and the server (204, 308), a processing delay at the server, a processing delay at the device; and When performing the intermediate action (206), the at least one user-controllable object is moved from the given position toward the target position at the determined speed.

4. The apparatus (100) of claim 3, wherein the received instruction (208) indicates a time period within which the at least one user-controllable object (108, 302) is to reach the target location (110, 306), wherein the time period begins at a start time (t0) at which the user request (202) is received by the processor (112), and wherein the processor is configured to: adjusting the speed based on the time period within which the at least one user-controllable object will reach the target position and the distance between the target position and the current position of the at least one user-controllable object on the graphical user interface (102, 304); and - upon executing the received instruction, moving the at least one user-controllable object towards the target position at the adjusted speed.

5. The apparatus (100) of claim 2, wherein the intermediate action (206) comprises presenting only the visual indicator (310) on the graphical user interface (102, 304), and the received instruction (208) indicates a time period within which the at least one user-controllable object (108, 302) will reach the target location (110, 306), wherein the time period begins at a start time (t0) at which the user request (202) is received by the processor (112), wherein the processor is configured to: determining a speed at which the at least one user-controllable object is to be moved based on a distance between the given position (114) and the target position and the time period within which the at least one user-controllable object is to reach the target position; and When executing the received instruction, the at least one user-controllable object is moved from the given position toward the target position at the determined speed.

6. An apparatus (100) according to any one of the preceding claims, wherein the processor (112) is configured to determine a time period in which the intermediate action (206) is to be executed based on at least one of the following: a network delay between the apparatus and the server (204, 308), a processing delay at the server, a processing delay at the apparatus, wherein the execution of the intermediate action is terminated after completion of the determined time period.

7. The apparatus (100) according to any one of claims 1-5, wherein the execution of the intermediate action (206) is terminated when at least one of the following occurs: receiving said instruction (208) in relation to said user request (202), Processing of the instruction related to the user request, the processing being performed prior to execution of the instruction.

8. The apparatus (100) according to any one of the preceding claims, wherein the user request (202) is time stamped.

9. A system comprising a server (204, 308) communicatively coupled to a plurality of devices (100) as claimed in any one of the preceding claims, wherein the plurality of devices collaborate via respective graphical user interfaces (102, 304), the server being configured to: receiving corresponding user requests (202) from the plurality of devices to perform corresponding requested actions (210) on the corresponding graphical user interfaces; collecting, from among the received user requests, a given set of user requests that have been received during a given time interval; processing the given set of user requests to create corresponding instructions (208) related to the user requests in the given set, wherein when processing the given set of user requests, the server is configured to determine a time period within which the corresponding request action is to be performed based on different network delays between the server and various devices, and wherein the corresponding instructions indicate to the various devices the determined time period within which the corresponding request action is to be performed; as well as The corresponding instructions related to the user requests in the given set are sent to the plurality of devices.

10. The system of claim 9, wherein the server (204, 308) is configured to adjust the given time interval based on fluctuations in the network delay.

11. A computer-implemented method comprising: Generating a graphical user interface (102, 304) and displaying the graphical user interface (102, 304) on a display screen of the device (100); receiving a user request (202) to perform a requested action (210) on the graphical user interface; Sending the user request to a server (204, 308); performing an intermediate action (206) on the graphical user interface while waiting for the server to create and provide instructions related to the user request; receiving the instruction related to the user request from the server (208); terminating the execution of the intermediate action; as well as The received instructions related to the user request are executed on the graphical user interface.

12. The computer-implemented method of claim 11, wherein the requested action (210) comprises repositioning at least one user-controllable object (108, 302) from a given position (114) to a target position (110, 306) on the graphical user interface (102, 304), and the intermediate action (206) comprises at least one of the following: presenting a visual indicator (310) on the graphical user interface to indicate that repositioning of the at least one user-controllable object is in progress, Movement of the at least one user-controllable object from the given position toward the target position is shown on the graphical user interface.

13. The computer-implemented method of claim 12, further comprising determining a speed at which the at least one user-controllable object (108, 302) is to be moved based on a distance between the given location (114) and the target location (110, 306), and optionally based on at least one of: a network delay between the device and the server (204, 308), a processing delay at the server, a processing delay at the device, The step of performing the intermediate action (206) includes: The at least one user-controllable object is moved from the given position toward the target position at the determined speed.

14. The computer-implemented method of claim 13, wherein the received instruction (208) indicates a time period within which the at least one user-controllable object (108, 302) is to reach the target location (110, 306), wherein the time period begins at a start time (t0) at which the user request (202) is received, and wherein the method further comprises: adjusting the speed based on the time period within which the at least one user-controllable object will reach the target position and the distance between the target position and the current position of the at least one user-controllable object on the graphical user interface (102, 304), The step (208) of executing the received instruction includes moving the at least one user-controllable object toward the target location at the adjusted speed.

15. The computer-implemented method of claim 12, wherein the intermediate action (206) comprises presenting only the visual indicator (310) on the graphical user interface (102, 304), and the received instruction (208) indicates a time period within which the at least one user-controllable object (108, 302) is to reach the target location (110, 306), wherein the time period begins at a start time (t0) at which the user request (202) is received, and wherein the method further comprises: determining a speed at which the at least one user-controllable object is to be moved based on a distance between the given position (114) and the target position and the time period within which the at least one user-controllable object is to reach the target position, The step of executing the received instruction comprises: moving the at least one user-controllable object from the given position toward the target position at the determined speed.

16. The computer-implemented method according to any one of claims 11-15, further comprising determining a time period in which the intermediate action (206) will be executed based on at least one of the following: a network delay between the device (100) and the server (204, 308), a processing delay at the server, a processing delay at the device, wherein the execution of the intermediate action is terminated after completion of the determined time period.

17. The computer-implemented method of any of claims 11-15, wherein the execution of the intermediate action (206) is terminated when at least one of: receiving said instruction (208) in relation to said user request (202), Processing of the instruction related to the user request, the processing being performed prior to execution of the instruction.

18. The computer-implemented method of any one of claims 11-17, further comprising: The user request is time stamped (202).

19. The computer-implemented method of any one of claims 11-18, further comprising: receiving, at the server (204, 308), respective user requests (202) from the plurality of devices (100) to perform respective requested actions (210) on respective graphical user interfaces (102, 304), wherein the plurality of devices collaborate via the respective graphical user interfaces; collecting, at the server, from among the received user requests, a given set of user requests that have been received during a given time interval; processing the given set of user requests at the server to create corresponding instructions (208) related to the user requests in the given set, wherein the step of processing the given set of user requests comprises: determining a time period within which the corresponding request action is to be performed based on different network delays between the server (204, 308) and respective devices, and wherein the corresponding instructions indicate to the respective devices the determined time period within which the corresponding request action is to be performed; as well as The corresponding instructions related to the user requests in the given set are sent from the server to the plurality of devices.

20. A computer program product comprising a non-transitory computer-readable storage medium having computer-readable instructions stored thereon, the computer-readable instructions being executable by a computing device comprising a processor (112) to perform the method according to any one of claims 11-19.

Images