Multi-terminal page synchronization method and system therefor

Abstract

A multi-terminal page synchronization method according to an embodiment of the present disclosure is performed by a computing device, and may comprise the steps of: when an application is executed in a first user terminal, storing, in a stack, a page identifier corresponding to a page newly displayed on the first user terminal whenever the page of the application is switched; when the application is executed in a second user terminal, comparing a first user identifier of the application executed in the first user terminal to a second user identifier of the application executed in the second user terminal; and, if the first user identifier is the same as the second user identifier, displaying, on the second user terminal, a page corresponding to the last stored page identifier from among page identifiers stored in the stack.

Description

Multi-terminal page synchronization method and system thereof

[0001] The present disclosure relates to a multi-terminal page synchronization method and system thereof, and more specifically, to a method and system thereof for maintaining user flow by synchronizing pages displayed on each terminal when the same application is executed on multiple user terminals.

[0002] When a user has multiple devices, such as a smartphone, tablet, desktop, laptop, TV, and car, the inconvenience of not being able to continue viewing an application page running on one device on another device arises. For example, if a user running an application on a smartphone wants to use the service on a wider screen and then launches the application on a tablet or desktop, they must then return to the page they were viewing on their smartphone to view it, which is inconvenient. While technologies such as mirroring exist for synchronizing multiple screens, these synchronize screen states in real time, and thus have many limitations, making it difficult to maintain user flow across multiple devices.

[0003] The technical problem to be solved through embodiments of the present disclosure is to provide a method for maintaining user flow by synchronizing pages of an application across multiple user terminals by storing and managing page identifiers corresponding to newly displayed pages whenever a page is switched in an application.

[0004] A multi-terminal page synchronization method according to an embodiment of the present disclosure may be performed by a computing device, and may include the steps of: storing a page identifier corresponding to a page newly displayed on a first user terminal in a stack whenever a page of the application is switched when an application is executed on a first user terminal; comparing a first user identifier of the application executed on the first user terminal with a second user identifier of the application executed on the second user terminal when the application is executed on a second user terminal; and, when the first user identifier and the second user identifier are the same, displaying a page corresponding to a page identifier that is most recently stored among the page identifiers stored in the stack on the second user terminal.

[0005] In one embodiment, the method may further include the step of storing, in the stack, a page identifier corresponding to a page newly displayed on the second user terminal whenever the page of the application is switched when the application is executed on the second user terminal.

[0006] In one embodiment, the step of storing the page identifier in the stack may include, when the number of page identifiers stored in the stack exceeds the size of the stack, deleting the page identifier stored first and then storing a page identifier corresponding to the newly displayed page in the stack.

[0007] In one embodiment, the method may further include a step of deleting page identifiers stored in the stack, among which a preset storage period has elapsed.

[0008] In one embodiment, the step of storing the page identifiers in the stack includes the step of storing the plurality of page identifiers corresponding to the plurality of pages as one page identifier group, when each of the plurality of pages constitutes one procedure, wherein when counting the number of page identifiers stored in the stack, the one page identifier group may be regarded as one.

[0009] In one embodiment, the plurality of pages constituting the one procedure may include a shopping cart page, an order form page, and a payment page.

[0010] In one embodiment, the page identifier may include information about the path of the page, parameters associated with the page, and an anchor of the page.

[0011] In one embodiment, the page identifier may be implemented in any one of JSON format, URI format, or XML format.

[0012] In one embodiment, the step of displaying on the second user terminal may include, if there are two or more page identifiers stored in the stack, displaying on the second user terminal a page corresponding to a page identifier stored before the most recently stored page identifier in response to a user's back command.

[0013] In one embodiment, the method may further include a step of displaying a page corresponding to the most recently stored page identifier on the first user terminal when the application is terminated and then re-executed on the first user terminal.

[0014] In one embodiment, the method further comprises the steps of sharing the stack to a user of a third user terminal, and, when the application is executed on the third user terminal, displaying a page corresponding to the most recently stored page identifier on the third user terminal, wherein the third user identifier of the application executed on the third user terminal is different from the first user identifier and the second user identifier.

[0015] According to another embodiment of the present disclosure, a multi-terminal page synchronization system includes a processor and a memory storing instructions, wherein the instructions, when executed by the processor, cause the processor to perform an operation of storing a page identifier corresponding to a page newly displayed on a first user terminal in a stack whenever a page of the application is switched when an application is executed on a first user terminal; an operation of comparing a first user identifier of the application executed on the first user terminal with a second user identifier of the application executed on the second user terminal when the application is executed on a second user terminal; and an operation of displaying a page corresponding to a page identifier that is most recently stored among the page identifiers stored on the stack on the second user terminal when the first user identifier and the second user identifier are the same.

[0016] In one embodiment, the instructions, when executed by the processor, may further cause the processor to perform an operation of storing, in the stack, a page identifier corresponding to a page newly displayed on the second user terminal whenever a page of the application is switched when the application is executed on the second user terminal.

[0017] In one embodiment, the operation of storing the page identifier in the stack may include, if the number of page identifiers stored in the stack exceeds the size of the stack, deleting the page identifier stored first and then storing the page identifier corresponding to the newly displayed page in the stack.

[0018] In one embodiment, the operation of storing the page identifiers in the stack includes an operation of storing the plurality of page identifiers corresponding to the plurality of pages as one page identifier group, when each of the plurality of pages constitutes one procedure, wherein when counting the number of page identifiers stored in the stack, the one page identifier group may be regarded as one.

[0019] In one embodiment, the plurality of pages constituting the one procedure may include a shopping cart page, an order form page, and a payment page.

[0020] In one embodiment, the operation of displaying on the second user terminal may include, if there are two or more page identifiers stored in the stack, an operation of displaying on the second user terminal a page corresponding to a page identifier stored before the most recently stored page identifier in response to a user's back command.

[0021] In one embodiment, the instructions, when executed by the processor, may further cause the processor to perform an operation of displaying, on the first user terminal, a page corresponding to the most recently stored page identifier, when the application is terminated and then re-executed on the first user terminal.

[0022] In one embodiment, the instructions, when executed by the processor, cause the processor to further perform the following actions: sharing the stack with a user of a third user terminal; and displaying a page corresponding to the most recently stored page identifier on the third user terminal when the application is executed on the third user terminal, wherein the third user identifier of the application executed on the third user terminal is different from the first user identifier and the second user identifier.

[0023] FIG. 1 is a block diagram exemplarily showing the configuration of an entire system including a multi-terminal page synchronization system according to an embodiment of the present disclosure.

[0024] FIG. 2 exemplarily illustrates the operation of a multi-terminal page synchronization system according to an embodiment of the present disclosure.

[0025] FIG. 3 exemplarily illustrates the configuration of a stack according to an embodiment of the present disclosure.

[0026] FIG. 4 exemplarily illustrates the configuration of a page identifier group according to an embodiment of the present disclosure.

[0027] FIG. 5 is a flowchart exemplarily illustrating a multi-terminal page synchronization method according to an embodiment of the present disclosure.

[0028] FIG. 6 is a flowchart specifically illustrating an embodiment of a step of storing the page identifier of FIG. 5 in a stack.

[0029] FIG. 7 is a flowchart specifically illustrating another embodiment of the step of storing the page identifier of FIG. 5 in a stack.

[0030] FIG. 8 is a flowchart specifically illustrating an embodiment of a step of displaying a page corresponding to the last stored page identifier of FIG. 5 on a second user terminal.

[0031] FIG. 9 is a flowchart exemplarily illustrating a multi-terminal page synchronization method according to another embodiment of the present disclosure.

[0032] FIG. 10 is a flowchart exemplifying a multi-terminal page synchronization method according to another embodiment of the present disclosure.

[0033] FIG. 11 is a block diagram showing the hardware configuration of a computing device for a multi-terminal page synchronization method according to an embodiment of the present disclosure.

[0034] Hereinafter, preferred embodiments of the present disclosure will be described in detail with reference to the attached drawings. The advantages and features of the present disclosure, and methods for achieving them, will become clearer with reference to the embodiments described in detail below together with the attached drawings. However, the present disclosure is not limited to the embodiments described below and may be implemented in various different forms. These embodiments are provided only to ensure that the present disclosure is complete and to fully inform those skilled in the art of the present disclosure of the scope of the invention, and the present disclosure is defined solely by the scope of the claims.

[0035] When designating components in each drawing, it should be noted that identical components are assigned identical reference numerals whenever possible, even if they appear on different drawings. Furthermore, when describing the present disclosure, detailed descriptions of related known components or functions are omitted if they are deemed to obscure the gist of the present disclosure.

[0036] Unless otherwise defined, all terms (including technical and scientific terms) used herein may be used in the same sense as commonly understood by those of ordinary skill in the art to which this disclosure pertains. Furthermore, terms defined in commonly used dictionaries are not to be interpreted ideally or excessively unless explicitly and specifically defined otherwise. The terminology used herein is for the purpose of describing embodiments and is not intended to limit the present invention. In this specification, singular forms also include plural forms, unless specifically stated otherwise.

[0037] Additionally, terms such as first, second, A, B, (a), (b), etc. may be used to describe components of the present disclosure. These terms are only intended to distinguish the components from other components, and the nature, order, or sequence of the components are not limited by the terms. When a component is described as being "connected," "coupled," or "connected" to another component, it should be understood that the component may be directly connected or connected to the other component, but another component may also be "connected," "coupled," or "connected" between each component.

[0038] The terms "comprises" and / or "comprising" as used in the specification do not exclude the presence or addition of one or more other components, steps, operations and / or elements.

[0039] FIG. 1 is a block diagram exemplarily showing the configuration of an entire system (10) including a multi-terminal page synchronization system (200) according to an embodiment of the present disclosure. Referring to FIG. 1, the entire system (10) may include a plurality of user terminals (100-1, 100-2, 100-3), a multi-terminal page synchronization system (200), and a service server (300). The entire system (10) according to an embodiment of the present disclosure may synchronize application pages of a plurality of user terminals (e.g., 100-1, 100-2) receiving services from the service server (300) through the multi-terminal page synchronization system (200), thereby maintaining user flow. In this specification, it is assumed that the application is an application for receiving a shopping service from the service server (300).

[0040] User terminals (100-1, 100-2, 100-3) may be computing devices used by users to receive shopping services from the service server (300). For example, the first user terminal (100-1) and the second user terminal (100-2) may be terminals used by the first user, and the third user terminal (100-3) may be a terminal used by the second user. In this specification, it is assumed that applications running on user terminals of the same user (e.g., 100-1 and 100-2) have the same user identifier, and applications running on user terminals of different users (e.g., 100-1 and 100-3, or 100-2 and 100-3) have different user identifiers. For example, the same user identifier may mean that login information (i.e., user ID and password) matches.

[0041] Hereinafter, when referring to any user terminal (e.g., 100-1) or collectively referring to all user terminals (e.g., 100-1 to 100-3), they will all be referred to as reference numeral 100. For example, the user terminal (100) may include a smartphone, a tablet, a desktop, a laptop, etc. However, the present disclosure is not limited thereto, and the user terminal (100) may be implemented as any device. The user terminal (100) may also be referred to as a 'client terminal', a 'buyer / purchaser terminal', a 'consumer terminal', etc. Meanwhile, although FIG. 1 illustrates two users and three user terminals (100-1, 100-2, 100-3), the present disclosure is not limited thereto, and the multi-terminal page synchronization method according to an embodiment of the present disclosure can be similarly applied to a larger number of users and a larger number of user terminals.

[0042] The multi-terminal page synchronization system (200) can store a page identifier corresponding to a page newly displayed on the first user terminal (100-1) in a stack (210) whenever the page of the application is switched when the application is executed on the first user terminal (100-1). Although the multi-terminal page synchronization system (200) is shown as including one stack (210) in FIG. 1, the multi-terminal page synchronization system (200) may actually include a stack (210) that stores a page identifier for each user. For example, the page identifier may include a path of the page, parameters related to the page, information about an anchor of the page, etc., and may be implemented in any one of a JSON format, a URI format, or an XML format, but the present disclosure is not limited thereto.

[0043] The total number of page identifiers that can be stored may be determined based on the size of the stack (210). For example, if the total number of page identifiers exceeds the size of the stack (210), the page identifier that was stored first may be deleted from the stack (210), and then a page identifier corresponding to a newly displayed page may be newly stored. In addition, each page identifier may be stored for a preset storage period, and page identifiers that have exceeded the storage period may be deleted from the stack (210). The size and storage period of the stack may be managed as a single policy in the multi-terminal page synchronization system (200).

[0044] Furthermore, when multiple pages in an application each constitute a single procedure (e.g., when each constitutes a product order procedure, such as a shopping cart page, an order form page, and a payment page), multiple page identifiers corresponding to the multiple pages can be stored and managed as a single page identifier group. Multiple page identifiers managed as a single page identifier group in this way can be counted as one when counting the number of page identifiers. For example, when a stack (210) includes a page identifier group including three page identifiers and four page identifiers, the stack (210) can be counted as including five page identifiers rather than seven page identifiers. By managing multiple pages as a single page identifier group in this way, when performing functionally related procedures on multiple terminals (e.g., when searching for a product on a desktop, adding it to a shopping cart, and then attempting to pay on a smartphone), the user flow can be maintained more closely.

[0045] Thereafter, when the application is executed on a second user terminal (100-2), which is another terminal of the same user, the first user identifier of the application executed on the first user terminal (100-1) and the second user identifier of the application executed on the second user terminal (100-2) may be compared. As described above, the comparison of the user identifiers may be performed through comparison of login information, and if the login information is the same, the user identifiers may be determined to be the same, and if the login information is different, the user identifiers may also be determined to be different.

[0046] When the first user identifier and the second user identifier are the same, the multi-terminal page synchronization system (200) can display the page corresponding to the most recently stored page identifier among the page identifiers stored in the stack (210) on the second user terminal (100-2). That is, when a user executes an application on the second user terminal (100-2), the application page most recently displayed on the first user terminal (100-1) can be displayed. Meanwhile, when there are two or more page identifiers stored in the stack (210), when a user executes a back command on the application on the second user terminal (100-2), a page corresponding to a page identifier stored before the most recently stored page identifier can be displayed on the second user terminal (100-2). That is, according to an embodiment of the present disclosure, a user flow can be maintained when users execute applications on different terminals.

[0047] Meanwhile, even when the application is terminated and then re-executed on the first user terminal (100-1), the page corresponding to the page identifier most recently stored in the stack (210) may be re-displayed. In this way, according to the embodiment of the present disclosure, the user flow can be maintained even when the user terminates and then re-executes the application. This can also be applied when the application is terminated and then re-executed on another terminal (e.g., when the application is terminated on the first user terminal (100-1) and then re-executed on the second user terminal (100-2).

[0048] Furthermore, the multi-terminal page synchronization system (200) can store a page identifier corresponding to a page newly displayed on the second user terminal (100-2) in the stack (210) every time the page of the application is switched, even when the application is executed on the second user terminal (100-2). In other words, application pages executed on the same user's terminal can all be synchronized with each other through the page identifier of the stack (210).

[0049] And, according to an embodiment, a user can share a stack (210) with another user through the multi-terminal page synchronization system (200). For example, a first user using a first user terminal (100-1) and a second user terminal (100-2) can share a stack (210) with a second user using a third user terminal (100-3). The stack can be shared through a process in which the multi-terminal page synchronization system (200) copies the first user's stack and creates a stack for the third user. When the stack (210) is shared in this way, the multi-terminal page synchronization system (200) can display the page corresponding to the page identifier most recently stored in the stack (210) on the third user terminal (100-3) even when an application is executed on the third user terminal (100-3). This allows sharing of user flows between different users, thereby improving decision-making efficiency of different users related to the service. At this time, the third user identifier of the application executed on the third user terminal (100-3) will be different from the first user identifier and the second user identifier described above.

[0050] For example, the multi-terminal page synchronization system (200) may be configured using one or more physical servers included in a server farm based on cloud technology such as a virtual machine.

[0051] The service server (300) may be a computing device / system (platform) that provides shopping services to customers. For example, the service server (300) may be a computing device / system that provides an online shopping site to a user terminal (100). The service server (300) may be implemented by at least one computing device. For example, all functions of the service server (300) may be implemented in a single computing device, or a first function of the service server (300) may be implemented in a first computing device, and a second function may be implemented in a second computing device. Alternatively, specific functions of the service server (300) may be implemented in multiple computing devices. For example, the computing device may include any type of device equipped with a computing means and a communication means.

[0052] In FIG. 1, the multi-terminal page synchronization system (200) and the service server (300) are shown as being separated, but depending on the embodiment, the function of the multi-terminal page synchronization system (200) may also be performed in the service server (300).

[0053] As illustrated in FIG. 1, a user terminal (100), a multi-terminal page synchronization system (200), and a service server (300) can communicate via a network. For example, the network can be implemented as any type of wired / wireless network, such as a local area network (LAN), a wide area network (WAN), a mobile radio communication network, or Wibro (Wireless Broadband Internet).

[0054] FIG. 2 exemplarily illustrates the operation of a multi-terminal page synchronization system (200) according to an embodiment of the present disclosure. Referring to FIG. 2 , when an application is first executed on a first user terminal (100-1), the displayed page is stored as a first page identifier in a stack (210) of the multi-terminal page synchronization system (200), and a page corresponding to the first page identifier is displayed on a second user terminal (100-2). Here, the first user terminal (100-1) may be a smartphone, and the second user terminal (100-2) may be a desktop or laptop. Conversely, even when the application is first executed on the second user terminal (100-2), the displayed page may be stored as a first page identifier in the stack (210), and a page corresponding to the first page identifier may be displayed on the first user terminal (100-1). In this way, by maintaining user flow among multiple user terminals, users can receive services by selecting a user terminal appropriate for the situation.

[0055] FIG. 3 exemplarily illustrates the configuration of a stack (210) according to an embodiment of the present disclosure. Referring to FIG. 3 , the multi-terminal page synchronization system (200) may include a first stack (210-1) corresponding to a first user, a second stack (210-2) corresponding to a second user, and a third stack (210-3) corresponding to a third user. In addition, the first stack (210-1) is shown to store five page identifiers, the second stack (210-2) is shown to store three page identifiers, and the third stack (210-3) is shown to not store any page identifiers. In this way, the multi-terminal page synchronization system (200) can manage stacks for each user of the service server (300), and the page identifier storage status of each stack may be different depending on the activity status of the user.

[0056] As described with reference to FIG. 1, when the number of stored page identifiers exceeds the size of the stack, the first stored page identifier may be deleted, and a page identifier corresponding to a newly displayed page may be stored. For example, assume that the size of the first stack (210-1) is 5, and the first page identifier is the first stored page identifier. In this case, after the storage of the fifth page identifier, the sixth page identifier corresponding to the newly displayed page may be stored after the deletion of the first page identifier. In addition, as described with reference to FIG. 1, among the page identifiers shown in FIG. 3, a page identifier for which a preset storage period has elapsed may be deleted from the stack (210-1 or 210-2).

[0057] FIG. 4 exemplarily illustrates the configuration of a page identifier group according to an embodiment of the present disclosure. Referring to FIG. 4 , it is assumed that a shopping cart page, an order page, and a payment page are displayed on a first user terminal (100-1), and correspond to a third page identifier, a fourth page identifier, and a fifth page identifier, respectively. At this time, since the shopping cart page, the order page, and the payment page constitute a single procedure and are functionally related to each other, the multiple page identifiers corresponding to them can be managed as a single page identifier group (G1). At this time, the stack can be considered to include three page identifiers, rather than five. According to this page identifier group (G1), corresponding pages can also be displayed on a second user terminal (100-2).

[0058] FIG. 5 is a flowchart exemplifying a multi-terminal page synchronization method according to an embodiment of the present disclosure. For reference, FIG. 5 illustrates steps / operations of the multi-terminal page synchronization method performed in the multi-terminal page synchronization system (200) of FIG. 1. Accordingly, in the following descriptions, if the subject of a specific step / operation is omitted, it can be understood that it is performed in the multi-terminal page synchronization system (200). The following description will be made with reference to FIG. 1 along with FIG. 5.

[0059] In step S100, whenever the page of the application is switched in the first user terminal (100-1), a page identifier corresponding to the newly displayed page may be stored in the stack (210). As described above, the page identifier may include a path of the page, parameters related to the page, information about an anchor of the page, etc., and may be implemented in any one of JSON format, URI format, and XML format. In step S200, a first user identifier of an application executed in the first user terminal (100-1) and a second user identifier of an application executed in the second user terminal (100-2) may be compared. For example, the comparison between the first user identifier and the second user identifier may be performed through a comparison of login information. That is, if the login information of the application executed in the first user terminal (100-1) and the login information of the application executed in the second user terminal (100-2) are the same, the first user identifier and the second user identifier may be determined to be the same.

[0060] In step S300, if the first user identifier and the second user identifier are the same, the page corresponding to the last page identifier stored in the stack (210) can be displayed on the second user terminal (100-2). As a result, the application page displayed on the first user terminal (100-1) and the application page displayed on the second user terminal (100-2) can be synchronized with each other, and the user flow can be maintained on other terminals of the same user.

[0061] In step S400, whenever a page of the application is switched on the second user terminal (100-2), a page identifier corresponding to the newly displayed page may be stored in the stack (210). That is, through steps S100 and S400, whenever a page is switched on all terminals of the same user on which the application is executed, the page identifier may be stored and managed in the stack (210).

[0062] With reference to FIGS. 6 to 10 below, embodiments related to the multi-terminal page synchronization method will be examined in more detail.

[0063] FIG. 6 is a flowchart specifically illustrating an embodiment of a step (S100) of storing a page identifier of FIG. 5 in a stack. Referring to FIG. 6, in step S110, it can be determined whether the number of page identifiers stored in the stack (210) exceeds the size of the stack (210). If the number of stored page identifiers exceeds the size of the stack (210) (YES), in step S120, after the page identifier stored first is deleted, a page identifier corresponding to a newly displayed page can be stored in the stack (210).

[0064] FIG. 7 is a flowchart specifically illustrating another embodiment of the step (S100) of storing page identifiers of FIG. 5 in a stack. Referring to FIG. 7, in step S130, it can be determined whether each of the multiple pages displayed on the first user terminal (100-1) constitutes a single procedure (i.e., are functionally related to each other). If each of the multiple pages constitutes a single procedure (YES), in step S140, multiple page identifiers corresponding to the multiple pages can be stored as a single page identifier group.

[0065] FIG. 8 is a flowchart specifically illustrating an embodiment of a step (S300) of displaying a page corresponding to the most recently stored page identifier of FIG. 5 on a second user terminal. Referring to FIG. 8, in step S310, it may be determined whether there are two or more page identifiers stored in the stack (210). If there are two or more stored page identifiers (YES), in step S320, when a user executes a back command on the application, in response to the user's back command, a page corresponding to a page identifier stored before the most recently stored page identifier may be displayed on the second user terminal (100-2). In this way, by allowing not only the most recently stored page identifier but also pages corresponding to previously stored page identifiers to be displayed, the user flow can be maintained more closely.

[0066] FIG. 9 is a flowchart exemplarily illustrating a multi-terminal page synchronization method according to another embodiment of the present disclosure. Referring to FIG. 9, after step S400, in step S500, even when the application is terminated and then re-executed on the first user terminal (100-1), the page corresponding to the most recently stored page identifier may be displayed on the first user terminal (100-1). Meanwhile, as described above, this may also be applied when the application is terminated on the first user terminal (100-1) and then re-executed on the second user terminal (100-2), or when the application is terminated on the second user terminal (100-2) and then re-executed on the first user terminal (100-1).

[0067] FIG. 10 is a flowchart exemplifying a multi-terminal page synchronization method according to another embodiment of the present disclosure. Referring to FIG. 10, after step S400, in step S600, the stack (210) may be shared with a user of a third user terminal (100-3). For example, step S600 may be performed by copying the stack (210) and creating a stack corresponding to the user of the third user terminal (100-3). In addition, in step S700, when an application is executed on the third user terminal (100-3), the page corresponding to the most recently stored page identifier may be displayed on the third user terminal (100-3). Here, it is assumed that the users of the first user terminal (100-1) and the second user terminal (100-2) and the user of the third user terminal (100-3) are different, and accordingly, it is assumed that the third user identifier of the application running on the third user terminal (100-3) is different from the first user identifier and the second user identifier described above.

[0068] Although the flowcharts shown in FIGS. 9 and 10 are illustrated as separate embodiments, the present disclosure is not limited thereto, and the methods shown in FIGS. 5, 9, and 10 may all be performed in one embodiment.

[0069] FIG. 11 is a block diagram showing the hardware configuration of a computing device (500) for a multi-terminal page synchronization method according to an embodiment of the present disclosure.

[0070] Referring to FIG. 11, a computing device (500) may include one or more processors (510), a bus (530), a communication interface (540), a memory (520) for loading a computer program executed by the processor (510), and a storage (550) for storing a computer program (560). However, only components related to the embodiment of the present disclosure are illustrated in FIG. 11. Therefore, a person skilled in the art to which the present disclosure pertains will appreciate that other general components may be included in addition to the components illustrated in FIG. 11. That is, the computing device (500) may further include various components in addition to the components illustrated in FIG. 11. In addition, in some cases, the computing device (500) may be configured in a form in which some of the components illustrated in FIG. 11 are omitted. Hereinafter, each component of the computing device (500) will be described.

[0071] The processor (510) can control the overall operation of each component of the computing device (500). The processor (510) can be configured to include at least one of a Central Processing Unit (CPU), a Micro Processor Unit (MPU), a Micro Controller Unit (MCU), a Graphics Processing Unit (GPU), or any other type of processor well known in the art of the present disclosure. In addition, the processor (510) can perform operations for at least one application or program for executing operations / methods according to embodiments of the present disclosure. The computing device (500) can include one or more processors.

[0072] Next, the memory (520) can store various data, commands, and / or information. The memory (520) can load a computer program (560) from the storage (550) to execute operations / methods according to embodiments of the present disclosure. The memory (520) may be implemented as a volatile memory such as RAM, but the present disclosure is not limited thereto.

[0073] Next, the bus (530) can provide communication functions between components of the computing device (500). The bus (530) can be implemented as various types of buses, such as an address bus, a data bus, and a control bus.

[0074] Next, the communication interface (540) can support wired and wireless Internet communication of the computing device (500). Furthermore, the communication interface (540) can also support various communication methods other than Internet communication. To this end, the communication interface (540) can be configured to include a communication module well known in the technical field of the present disclosure.

[0075] Next, the storage (550) can non-temporarily store one or more computer programs (560). The storage (550) can be configured to include non-volatile memory such as Read Only Memory (ROM), Erasable Programmable ROM (EPROM), Electrically Erasable Programmable ROM (EEPROM), flash memory, a hard disk, a removable disk, or any form of computer-readable recording medium well known in the art to which the present disclosure pertains.

[0076] Next, the computer program (560) may include one or more instructions that, when loaded into the memory (520), cause the processor (510) to perform operations / methods according to various embodiments of the present disclosure. That is, the processor (510) may perform operations / methods according to various embodiments of the present disclosure by executing the loaded one or more instructions.

[0077] For example, the computer program (560) may include instructions for storing a page identifier corresponding to a page newly displayed on the first user terminal in a stack whenever a page of the application is switched when an application is executed on a first user terminal, comparing a first user identifier of the application executed on the first user terminal with a second user identifier of the application executed on the second user terminal when an application is executed on a second user terminal, and, if the first user identifier and the second user identifier are the same, displaying a page corresponding to the last page identifier stored in the stack on the second user terminal.

[0078] Additionally, the computer program (560) may further include instructions for displaying a page corresponding to the most recently saved page identifier on the first user terminal when the application is executed again after being terminated on the first user terminal, sharing the stack with a user of a third user terminal, and displaying a page corresponding to the most recently saved page identifier on the third user terminal when the application is executed on the third user terminal.

[0079] According to embodiments of the present disclosure, if an application is unintentionally terminated due to reasons such as insufficient memory or a system shutdown, the last page can be restored using a stored page identifier. Furthermore, if a user temporarily suspends the application on an important page, such as a payment page, the user flow can be maintained by displaying the page at the point of suspension when the application is restarted. Alternatively, according to embodiments of the present disclosure, a user can browse products on a desktop or laptop PC web browser and then proceed with the ordering process on a smartphone, where payment is convenient, thereby enhancing the user experience. Furthermore, by allowing a user to share a stack containing their personal page identifiers with other users, the user flow can be maintained among multiple users.

[0080] Various embodiments of the present disclosure and effects according to the embodiments have been described with reference to FIGS. 1 through 11. The effects according to the technical concept of the present disclosure are not limited to the effects mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

[0081] Although all components constituting the embodiments of the present disclosure have been described as being combined or operating in combination as one, the present disclosure is not necessarily limited to such embodiments. That is, within the scope of the present disclosure, all components may be selectively combined and operated in one or more combinations.

[0082] Although operations are depicted in the drawings in a particular order, this should not be understood to imply that the operations must be performed in the particular order depicted, or in any sequential order, or that all depicted operations must be performed to achieve the desired results. In certain circumstances, multitasking and parallel processing may be advantageous. Furthermore, the separation of the various components in the embodiments described above should not be understood to imply that such separation is absolutely necessary, and it should be understood that the program components and systems described may generally be integrated together into a single software product or packaged into multiple software products.

[0083] Although the embodiments of the present disclosure have been described with reference to the attached drawings, those skilled in the art will appreciate that the present disclosure can be implemented in other specific forms without altering the technical spirit or essential features thereof. Therefore, it should be understood that the embodiments described above are exemplary in all respects and not restrictive. The scope of protection of the present disclosure should be interpreted by the claims below, and all technical ideas within a scope equivalent thereto should be interpreted as being included within the scope of the rights of the present disclosure.

Claims

1. In a multi-terminal page synchronization method performed by a computing device, When an application is executed on a first user terminal, a step of storing a page identifier corresponding to a page newly displayed on the first user terminal in a stack whenever a page of the application is switched; When the application is executed on the second user terminal, a step of comparing the first user identifier of the application executed on the first user terminal with the second user identifier of the application executed on the second user terminal; and Including a step of displaying, on the second user terminal, a page corresponding to the last stored page identifier among the page identifiers stored in the stack, if the first user identifier and the second user identifier are the same. How to synchronize multiple terminal pages.

2. In paragraph 1, Further comprising a step of storing a page identifier corresponding to a page newly displayed on the second user terminal in the stack whenever the page of the application is switched when the application is executed on the second user terminal. How to synchronize multiple terminal pages.

3. In paragraph 1, The steps to store the above page identifier in the stack are: If the number of page identifiers stored in the stack exceeds the size of the stack, a step of deleting the page identifier stored first and then storing the page identifier corresponding to the newly displayed page in the stack is included. How to synchronize multiple terminal pages.

4. In paragraph 1, Further comprising a step of deleting page identifiers among the page identifiers stored in the stack, the page identifiers of which a preset storage period has expired. How to synchronize multiple terminal pages.

5. In paragraph 1, The steps to store the above page identifier in the stack are: In a case where each of a plurality of pages constitutes one procedure, a step of storing a plurality of page identifiers corresponding to the plurality of pages as one page identifier group is included. When counting the number of page identifiers stored in the above stack, one group of page identifiers is considered as one. How to synchronize multiple terminal pages.

6. In paragraph 5, The multiple pages that constitute the above one procedure include a shopping cart page, an order page, and a payment page. How to synchronize multiple terminal pages.

7. In paragraph 1, The above page identifier includes information about the path of the page, parameters related to the page, and anchors of the page. How to synchronize multiple terminal pages.

8. In paragraph 7, The above page identifier is implemented in either JSON format, URI format, or XML format. How to synchronize multiple terminal pages.

9. In paragraph 1, The steps displayed on the second user terminal are: If there are two or more page identifiers stored in the stack, a step of displaying, on the second user terminal, a page corresponding to a page identifier stored before the last stored page identifier in response to a user's back command, How to synchronize multiple terminal pages.

10. In paragraph 1, Further comprising the step of displaying a page corresponding to the most recently stored page identifier on the first user terminal when the application is executed again after being terminated on the first user terminal. How to synchronize multiple terminal pages.

11. In paragraph 1, A step of sharing the above stack to a user of a third user terminal; and When the application is executed on the third user terminal, the method further comprises the step of displaying a page corresponding to the most recently stored page identifier on the third user terminal, The third user identifier of the application executed on the third user terminal is characterized in that it is different from the first user identifier and the second user identifier. How to synchronize multiple terminal pages.

12. Processor; and Contains memory that stores instructions, The above instructions, when executed by the processor, cause the processor to: When an application is executed on a first user terminal, an action of storing a page identifier corresponding to a page newly displayed on the first user terminal in a stack whenever a page of the application is switched; An operation of comparing a first user identifier of the application executed on the first user terminal with a second user identifier of the application executed on the second user terminal when the application is executed on the second user terminal; and If the first user identifier and the second user identifier are the same, an operation is performed to display a page corresponding to the last stored page identifier among the page identifiers stored in the stack on the second user terminal. Multi-terminal page synchronization system.

13. In paragraph 12, The above instructions, when executed by the processor, cause the processor to: When the application is executed on the second user terminal, an operation of storing a page identifier corresponding to a page newly displayed on the second user terminal in the stack is further performed whenever the page of the application is switched. Multi-terminal page synchronization system.

14. In paragraph 12, The action of saving the above page identifier to the stack is: If the number of page identifiers stored in the stack exceeds the size of the stack, the operation of deleting the page identifier stored first and then storing the page identifier corresponding to the newly displayed page in the stack is included. Multi-terminal page synchronization system.

15. In paragraph 12, The action of saving the above page identifier to the stack is: In a case where each of a plurality of pages constitutes one procedure, an operation of storing a plurality of page identifiers corresponding to the plurality of pages as one page identifier group is included. When counting the number of page identifiers stored in the above stack, one group of page identifiers is considered as one. Multi-terminal page synchronization system.

16. In paragraph 15, The multiple pages that constitute the above one procedure include a shopping cart page, an order page, and a payment page. Multi-terminal page synchronization system.

17. In paragraph 12, The actions displayed on the second user terminal are: If there are two or more page identifiers stored in the stack, an action is included to display, on the second user terminal, a page corresponding to a page identifier stored before the last stored page identifier in response to a user's back command. Multi-terminal page synchronization system.

18. In paragraph 12, The above instructions, when executed by the processor, cause the processor to: When the application is terminated and then re-executed on the first user terminal, an action is further performed to display the page corresponding to the most recently stored page identifier on the first user terminal. Multi-terminal page synchronization system.

19. In paragraph 12, The above instructions, when executed by the processor, cause the processor to: An action of sharing the above stack with a user of a third user terminal; and When the application is executed on the third user terminal, an action is further performed to display the page corresponding to the most recently stored page identifier on the third user terminal. The third user identifier of the application executed on the third user terminal is characterized in that it is different from the first user identifier and the second user identifier. Multi-terminal page synchronization system.

Images