How to support data collection

Abstract

According to several embodiments of the present disclosure, a method for supporting data collection in a user terminal including at least one processor is disclosed, which may include accessing a pre-designated library in response to execution of a target application, sending a report signal regarding readiness to receive a command to an address defined in the library, receiving a command signal defined in a first programming language, determining a response signal to the command signal depending on whether an application programming interface (API) corresponding to the command signal exists, and sending the response signal to the address defined in the library.

Description

[Technical Field]

[0001] The present disclosure relates to a method for supporting data collection, and more particularly to a method for supporting data collection in a user terminal. [Background technology]

[0002] The process of distributing apps for the Android operating system can be briefly summarized as follows:

[0003] Application Development: First, you need to develop the app that will run on the user's device. This process can include designing the user interface, implementing the app's logic, and testing.

[0004] Building the Application: Once you have completed developing your app, you need to build it. Building can refer to the process of compiling the source code and packaging it into an APK (Android Package) file.

[0005] Signing: Your app must be signed. Adding a signature to your APK file identifies your app as a trusted source. You can sign using a debug keystore for development or a release keystore.

[0006] Google Play Console Registration: To distribute your app to the Google Play Store, you need to register it with the Google Play Console, which allows you to set up app information, pricing, description, screenshots, version control, etc.

[0007] Upload APK: Upload your APK file in the Google Play Console. You can upload your APK file for release or set different release tracks such as Alpha, Beta, Production, etc.

[0008] Configure resources and store page: Configure resources such as app icon, graphics, description, and app store page.

[0009] Pricing and Country Settings: Set the price of your app and specify the countries it will be available in. You can choose whether to make it a free or paid app and manage your pricing policy.

[0010] Release and Review: Release your app on the Google Play Console and undergo a Google review process. The review checks the app's content, compliance with advertising policies, etc.

[0011] Distributing the application: Once the review is complete, distribute the app to the Google Play Store, where users can search for and download the app.

[0012] Manage application updates: When you need to update your app or release a new version, repeat the steps above to upload the new APK file and release it.

[0013] User support and feedback management: Managing communication with users who use the app, processing feedback and problem reports, and helping to improve the app.

[0014] Marketing and Promotion: After the app is successfully released, marketing and promotional activities are carried out to attract more users and promote the app.

[0015] Android applications developed as native apps usually need to follow the distribution process described above to update the application. The process of development, building, testing, and distribution requires a lot of time and resources, and even when updating the application, the development, building, and testing processes are still required. Furthermore, remote resource patching has limitations on changes, as it is not possible to change the executing entity. Summary of the Invention [Problem to be solved by the invention]

[0016] The present disclosure has been devised in response to the above-mentioned background art, and aims to provide a method for supporting data collection on a user terminal, which allows the items for which data is collected to be changed without rebuilding or redistributing the application.

[0017] The technical problems in the present disclosure are not limited to the above-mentioned technical problems, and a person skilled in the art can clearly understand problems other than the above-mentioned technical problems based on the following description. [Means for solving the problem]

[0018] According to an embodiment of the present disclosure to solve the above-mentioned problems, a method for supporting data collection in a user terminal including at least one processor is disclosed, which may include the steps of: accessing a pre-designated library in response to execution of a target application; sending a report signal regarding readiness to receive a command to an address defined in the library; receiving a command signal defined in a first programming language; determining a response signal to the command signal depending on whether an application programming interface (API) corresponding to the command signal exists; and sending the response signal to the address defined in the library.

[0019] Additionally, the API corresponding to the command signal can be defined in a second programming language corresponding to the operating system of the user terminal.

[0020] Furthermore, the step of determining the response signal may include a step of sending an output value defined in the API as the response signal to an address defined in the library if an API corresponding to the command signal exists in the library, or a step of sending an error signal for the command signal as the response signal to an address defined in the library if an API corresponding to the command signal does not exist in the library.

[0021] In addition, the step of determining a response signal to the command signal depending on whether or not an API (application programming interface) corresponding to the command signal exists may include a step of parsing the command signal to generate a command, and a step of executing the generated command to determine whether or not an API corresponding to the command signal exists in the library.

[0022] The command signal may also include at least one tag item that specifies the tag to be collected, and each of the at least one tag item may include a trigger item that sets the conditions under which the tag item is executed, and a variable item that specifies the data to be collected.

[0023] Furthermore, the command signal is generated so that the at least one tag item is selectively collected based on a user interaction input corresponding to a pre-specified graphic object, and the pre-specified graphic object may include a first graphic object indicating a collection command corresponding to a first tag item, a first-1 graphic object indicating an execution command related to a trigger condition associated with the first tag item, and a first-2 graphic object indicating a collection command for a variable related to the first tag item.

[0024] In addition, the step of determining a response signal to the command signal depending on whether an API (application programming interface) corresponding to the command signal exists may include a step of determining whether a first tag item exists, for which it is decided to collect tags from the at least one tag item based on the command signal; if the first tag item exists, a step of determining whether to collect a first trigger item included in the first tag item based on the command signal; and if the first tag item exists, a step of determining whether to collect a first variable item included in the first tag item based on the command signal.

[0025] Additionally, the at least one tag term may include at least one of a basic tag term that utilizes a predefined tag term and a user-created tag term.

[0026] Also, a method for supporting data collection in a server including at least one processor may include receiving a report signal from a user terminal regarding readiness to receive a command, transmitting a command signal defined in a first programming language in response to the report signal, and receiving a response signal to the command signal from the user terminal.

[0027] Furthermore, the step of receiving a response signal to the command signal from the user terminal may include a step of receiving an output value defined in the API as the response signal if an API corresponding to the command signal exists in the library of the user terminal, or a step of receiving an error signal as a response to the command signal if an API corresponding to the command signal does not exist in the library.

[0028] Additionally, the API corresponding to the command signal can be defined in a second programming language corresponding to the operating system of the user terminal.

[0029] Furthermore, when the command signal is parsed by the user terminal, it can be generated as a command to check whether an API corresponding to the command signal defined in the first programming language exists in the library.

[0030] The command signal may also include at least one tag item that specifies the tag to be collected, and each of the at least one tag item may include a trigger item that sets the conditions under which the tag item is executed, and a variable item that specifies the data to be collected.

[0031] Furthermore, the command signal is generated so that the at least one tag item is selectively collected based on a user interaction input corresponding to a pre-specified graphic object, and the pre-specified graphic object may include a first graphic object indicating a collection command corresponding to a first tag item, a first-1 graphic object indicating an execution command related to a trigger condition associated with the first tag item, and a first-2 graphic object indicating a collection command for a variable related to the first tag item.

[0032] Furthermore, the step of transmitting a command signal defined in a first programming language in response to the report signal may include a step of determining whether a first tag item exists, for which it is decided to collect tags from the at least one tag item, based on the user interaction input; if the first tag item exists, a step of determining whether to collect a first trigger item included in the first tag item, based on the user interaction input; and if the first tag item exists, a step of determining whether to collect a first variable item included in the first tag item, based on the user interaction input.

[0033] Additionally, the at least one tag term may include at least one of a basic tag term that utilizes a predefined tag term and a user-created tag term.

[0034] The technical solutions obtained from the present disclosure are not limited to the solutions described above, and a person having ordinary skill in the technical field to which the present disclosure pertains can clearly understand solutions other than the solutions described above from the following description. [Effects of the Invention]

[0035] According to multiple embodiments of the present disclosure, it is possible to provide a method for easily changing the items for which data is collected without rebuilding or redistributing the application.

[0036] The effects obtained from the present disclosure are not limited to the effects described above, and a person having ordinary knowledge in the technical field to which the present disclosure pertains can clearly understand effects other than those described above based on the following description.

[0037] Various aspects are described with reference to the drawings. In the following description of the drawings, like reference numerals are used to generally refer to like components. In the following examples, for purposes of explanation, numerous specific details are provided to facilitate an overall understanding of one or more aspects. However, it will be apparent that such aspect(s) may be practiced without such specific details. In other instances, well-known structures and devices are shown in block diagram form to facilitate describing one or more aspects. [Brief explanation of the drawings]

[0038] [Figure 1] 1 illustrates an exemplary system for implementing a method for supporting data collection, according to embodiments of the present disclosure. [Figure 2] 1 is a flowchart illustrating an example method for supporting data collection performed by a user terminal, according to embodiments of the present disclosure. [Figure 3] 10 is a flowchart illustrating an example method for a user terminal to transmit a response signal according to embodiments of the present disclosure. [Figure 4] 1 is a flowchart illustrating an example method for supporting server-performed data collection, according to embodiments of the present disclosure. [Figure 5] 1 is a diagram illustrating an example of a method for supporting data collection performed by a server and a user terminal, according to embodiments of the present disclosure. [Figure 6] 1 is a diagram illustrating an example of at least one tag item according to embodiments of the present disclosure. DETAILED DESCRIPTION OF THE INVENTION

[0039] The present invention is susceptible to various modifications and can have multiple embodiments. Specific embodiments are shown in the drawings and will be described in detail in the Detailed Description of the Invention. However, this does not limit the present invention to the specific embodiments, and it should be understood that the present invention includes all modifications, equivalents, and alternatives within the spirit and technical scope of the present invention. In describing the various drawings, similar reference symbols are used to refer to similar components.

[0040] Terms such as first, second, A, B, etc. are used to describe various components, but the components should not be limited by these terms. These terms are used only to distinguish one component from another. Thus, without departing from the scope of the present invention, a first component can be termed a second component, and similarly, a second component can be termed a first component. The term "and / or" is intended to include a combination of multiple associated listed items or any one of multiple associated listed items.

[0041] 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, coupled, or connected to the other component, but that there may be other components between them. On the other hand, when a component is described as being "directly connected," "directly coupled," or "directly connected" to another component, it should be understood that there are no other components between them.

[0042] The terms used in this application are used to describe particular embodiments and are not intended to limit the present invention. The singular term "a," "an," "an," or "an" includes the plural term unless the context clearly dictates otherwise. In this application, the terms "comprise," "include," "includes," "have," or "having" indicate the presence of features, numbers, steps, operations, components, parts, or combinations thereof described in the specification, but are not intended to preclude the possibility that one or more other features, numbers, steps, operations, components, parts, or combinations thereof may be present or added.

[0043] Unless otherwise defined, all terms used in this disclosure, including technical and scientific terms, have the same meaning as commonly understood by those having ordinary skill in the art to which this invention belongs, and terms defined in general dictionaries should be interpreted as having the same meaning in the context of the relevant art, and should not be interpreted ideally or in an overly formal sense unless otherwise defined in this specification.

[0044] In the present disclosure, a user terminal can receive a command signal from a server. Here, the command signal can be a script or the like. The script can be a programming language that can be executed without compiling source code. The user terminal can transmit a response signal corresponding to the received command signal to the server. Thus, a user of the server can collect data from the user terminal without rebuilding or redistributing the application.

[0045] Hereinafter, a method for supporting data collection performed by a user terminal will be described with reference to FIGS. 1 to 3, and a method for supporting data collection performed by a server will be described with reference to FIG.

[0046] FIG. 1 illustrates an exemplary system for implementing a method for supporting data collection, according to embodiments of the present disclosure.

[0047] Referring to FIG. 1, a system for performing a method for supporting data collection may include a server (100), a user terminal (200), and a network (300).

[0048] The server 100 may include any type of computer system or device, such as, for example, a microprocessor, a mainframe computer, a digital processor, a handheld device or device controller, or the like.

[0049] The server 100 may utilize a combination of typical computer hardware (e.g., devices that may include a computer processor, memory, storage, input and output devices, and other components of a conventional computing device; electronic communication devices such as routers and switches; and electronic information storage systems such as network-attached storage (NAS) and storage area networks (SAN)) and computer software (i.e., commands that cause a computing device to function in a particular manner) to achieve desired system performance.

[0050] The server 100 may include a control unit, a storage unit, a communication unit, etc. However, the above components are not essential for implementing the server 100, and the server 100 may include more or fewer components than the above components.

[0051] The processor 110 is generally capable of processing the overall operation of the server 100. The processor 110 processes signals, data, information, etc. input or output through components of the server 100, and runs application programs stored in the storage unit, thereby providing or processing appropriate information or functions for the user.

[0052] The processor (100) may be configured with one or more cores and may include a processor for data analysis, such as a central processing unit (CPU), a general purpose graphics processing unit (GPGPU), or a tensor processing unit (TPU).

[0053] The storage unit may include a memory and / or a permanent storage medium. The memory may include at least one type of storage medium among flash memory type, hard disk type, multimedia card micro type, card-type memory (e.g., SD or XD memory), Random Access Memory (RAM), Static Random Access Memory (SRAM), Read-Only Memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Programmable Read-Only Memory (PROM), magnetic memory, magnetic disk, and optical disk.

[0054] The communication unit may include one or more modules that enable communication between the server (100) and a communication system, between the server (100) and a user terminal (200), or between the server (100) and a network (300).

[0055] In the present disclosure, the server (100) can send a command signal to the user terminal (200). The command signal can be defined in a first programming language. The first programming language can be a scripting language. The scripting language can be a programming language that can be executed without compiling source code. When the command signal is received, the user terminal (200) can send a response signal to the server (100) using an API (application programming interface) corresponding to the command signal. This allows the server (100) to collect data from the user terminal (200). A method for supporting data collection performed by the server (100) will be described below with reference to FIG. 4.

[0056] The user terminal (200) can be a device that can achieve desired system performance using a combination of typical computer hardware (e.g., devices that can include a computer processor, memory, storage, input and output devices, and other components of a conventional computing device, electronic communication devices such as routers and switches, and electronic information storage systems such as network-attached storage (NAS) and storage area networks (SAN)) and computer software (i.e., commands that cause a computing device to function in a specific manner). The user terminal (200) can include a personal computer (PC), notebook computer, mobile terminal, smartphone, tablet PC, etc. owned by a user, and can include all types of terminals that can be connected to a wired or wireless network.

[0057] In the present disclosure, the user terminal (200) can transmit a response signal in response to a command signal received from the server (100). The response signal can include data collected by the user terminal (200). An example of a method for transmitting a response signal in response to a command signal received from the server (100) by the user terminal (200) will be described below with reference to FIGS. 2 and 3.

[0058] The network 300 can be a closed network such as a local area network (LAN) or a wide area network (WAN), or an open network such as the Internet, which refers to a global open computer network structure that provides the TCP / IP protocol and all services that exist above it, such as HyperText Transfer Protocol (HTTP), Telnet, File Transfer Protocol (FTP), Domain Name System (DNS), Simple Mail Transfer Protocol (SMTP), Simple Network Management Protocol (SNMP), Network File Service (NFS), and Network Information Service (NIS).

[0059] The following describes an example of a method for supporting data collection performed by a user terminal (200).

[0060] FIG. 2 is a flowchart illustrating an example method for supporting data collection performed by a user terminal, according to embodiments of the present disclosure.

[0061] Referring to FIG. 2, the user terminal (200) can access a pre-specified library in response to the execution of the target application (S110).

[0062] The target application may be an application that has been distributed in advance for data collection. The target application may be an application in which a software development kit (SDK) is installed in the form of a library. When the target application is executed based on input from a user, the user terminal (200) may access the pre-specified library.

[0063] The user terminal (200) can send a report signal regarding preparation for receiving a command to an address defined in the library (S120), where the address defined in the library can be an address at which the server (100) can receive the report signal.

[0064] The user terminal (200) can receive a command signal defined in a first programming language from the server (100) (S130). The first programming language can be a scripting language.

[0065] For example, the command signal can include scripts for deviceBrand, displaySize, and view("Button").text, etc.

[0066] According to one embodiment, a command signal defined by a first programming language may include at least one item.

[0067] Specifically, the command signal may include at least one of at least one tag item, a trigger item, and a variable item. The trigger item and the variable item may be subcomponents of the at least one tag item. That is, the at least one tag item may include a trigger item and a variable item.

[0068] The tag item can specify the item to be collected.

[0069] For example, a tag item can designate an item such as a click of a button, a click of a particular key, a click of a particular item, a touch, or a touch of a particular item as an item to be collected.

[0070] The trigger item can set the conditions under which the tag item is executed.

[0071] For example, a trigger item can be an item that causes data to be collected when an action such as clicking a button, clicking a specific key, clicking or touching a specific item occurs.

[0072] As another example, a trigger item can be an item that causes data to be collected when certain data changes.

[0073] A variable can be an item that specifies the data to collect. A variable can be set to collect specific data of a specific class.

[0074] In some embodiments of the present disclosure, the command signal may be generated to selectively collect at least one tag item, respectively, based on a user interaction input corresponding to a pre-specified graphic object, where the user interaction may be an interaction performed between the server (100) and a user of the server (100).

[0075] Specifically, each of the at least one tag item may correspond to each of the at least one graphical object. If a first tag item exists among the at least one tag item, a first graphical object corresponding to the first tag item may exist. The command signal may be generated in response to a user interaction with the first graphical object to selectively collect the first tag item.

[0076] For example, a command signal may be generated in response to a user interaction with the first graphical object to collect a first tag item. As another example, a command signal may be generated in response to a user interaction with the first graphical object to not collect a first tag item.

[0077] The pre-specified graphic objects may include a first graphic object indicating a collection command corresponding to the first tag item, a first-1 graphic object indicating an execution command for a trigger condition related to the first tag item, and a first-2 graphic object indicating a collection command for a variable related to the first tag item. The first-1 graphic object and the first-2 graphic object may be subordinate objects of the first graphic object.

[0078] Specifically, the command signal can be generated to collect a first tag item in response to a user input on the first graphical object, and when generated to collect the first tag item, the command signal can be generated to selectively collect a first trigger item in response to a user interaction on the first-1 graphical object.

[0079] For example, a command signal may be generated in response to a user interaction with the first-1 graphical object to collect the first trigger item. As another example, a command signal may be generated in response to a user interaction with the first-1 graphical object to not collect the first trigger item.

[0080] Also, when generated to collect the first tag item, the command signal can be generated to selectively collect the first variable item in response to a user interaction with the first-second graphic object.

[0081] For example, a command signal may be generated in response to a user interaction with the first-second graphical object to collect the first variable item. As another example, a command signal may be generated in response to a user interaction with the first-second graphical object to not collect the first variable item.

[0082] The user terminal (200) can determine a response signal to the command signal depending on whether or not an API (application programming interface) corresponding to the command signal exists (S140).

[0083] Specifically, the user terminal (200) can determine, based on the command signal, whether a first tag item exists, which is determined to collect tags from at least one tag item. If the first tag item exists, the user terminal (200) can determine, based on the command signal, whether to collect a first trigger item included in the first tag item. Also, if the first tag item exists, the user terminal (200) can determine, based on the command signal, whether to collect a first variable item included in the first tag item.

[0084] For example, the user terminal 200 may collect items related to the first tag item if the first tag item exists based on the command signal. The user terminal 200 may collect items such as a click of a button, a click of a specific key, a click of a specific item, a touch, or a touch of a specific item related to the first tag item. As another example, the user terminal 200 may determine to collect a tag from at least one tag item based on the command signal, but may not collect items related to the first tag item if the first tag item does not exist.

[0085] When the user terminal (200) determines to collect the first trigger item, it can collect data resulting from the occurrence of an action such as clicking a button related to the first trigger item, clicking a specific key, clicking a specific item, touching, or touching a specific item.

[0086] When the user terminal (200) decides to collect the first variable item, it can collect specific data of a specific class related to the first variable item.

[0087] The user terminal (200) can parse the command signal to generate a command. Parsing can be the act of breaking down a sentence into its constituent components and determining the hierarchical relationship of the broken down components to generate a command. The user terminal (200) can interpret the script content of the command signal and convert it into a command for execution. The user terminal (200) can execute the generated command and determine whether an API corresponding to the command signal exists in the library. Here, the API can be an interface defined in a second programming language corresponding to the operating system of the user terminal (200).

[0088] For example, the user terminal (200) may be an Android-based terminal, in which case the API may be an interface defined in a programming language compatible with the Android operating system.

[0089] As another example, the user terminal 200 may be an iOS-based terminal, in which case the API may be an interface defined in a programming language compatible with the iOS operating system.

[0090] In several embodiments of the present disclosure, the user terminal (200) can determine the response signal based on whether an API corresponding to the command signal exists in the library.

[0091] For example, if an API corresponding to a command signal exists in the library, the user terminal (200) can transmit an output value defined in the API as a response signal.

[0092] As another example, if the library does not contain an API corresponding to the command signal, the user terminal (200) can send an error signal as a response signal. An example of a method for the user terminal (200) to send a response signal will be described below with reference to FIG. 3.

[0093] The user terminal (200) can send a response signal to an address defined in the library (S150). Here, the address defined in the library can be an address at which the server (100) can receive the response signal. The address defined in the library can be an address at which the server (100) can receive data collected by the user terminal (200). Alternatively, the address defined in the library can be an external server for data collection designated by the user of the server (100).

[0094] For example, the command signal can include scripts for deviceBrand, displaySize, and view("Button").text, etc.

[0095] The API corresponding to the script related to deviceBrand can be an API that checks the brand of the user terminal 200. The user terminal 200 can return a brand such as "google," "samsung," or "apple" through the API.

[0096] The API corresponding to the script related to displaySize can be an API that checks the screen resolution of the user terminal (200). The user terminal (200) can return values ​​such as "1440" and "3036" through the API.

[0097] The API corresponding to the script related to view("Button") can be view(argument). The above API can search for a UI corresponding to the given argument and return an instance of the UI (a value that can uniquely identify the UI in the application).

[0098] The API corresponding to the .text script can be an instance, text, which can check and return the text displayed to the user from the UI instance.

[0099] The user terminal 200 can send the value returned by the API as a response signal to an address defined in the library. In one embodiment, the user terminal 200 can convert the returned value into human-readable text and send it to the server 100.

[0100] Based on the above-described configuration, the user terminal (200) can receive a command signal from the server (100). The user terminal can send data related to the command signal as a response signal to the server (100) or to an address defined in the library. The command signal can be a signal that does not require rebuilding or redistribution of the application. Therefore, the user of the server (100) can conveniently select and extract data to be collected from the user terminal (200) in real time.

[0101] On the other hand, in several embodiments of the present disclosure, the user terminal (200) can determine the response signal based on whether an API corresponding to the command signal exists in the library. Hereinafter, an example of a method in which the user terminal (200) transmits a response signal based on the present disclosure will be described with reference to FIG. 3 .

[0102] FIG. 3 is a flowchart illustrating an example method for a user terminal to transmit a response signal according to embodiments of the present disclosure.

[0103] Referring to FIG. 3, the user terminal (200) can determine whether an API corresponding to the command signal exists in the library.

[0104] If an API corresponding to the command signal exists in the library (S151, Yes), the user terminal (200) can send the output value defined in the API as a response signal to an address defined in the library (S152).

[0105] For example, the command signal can include scripts for deviceBrand, displaySize, and view("Button").text, etc.

[0106] The API corresponding to the script related to deviceBrand can be an API that checks the brand of the user terminal (200). If an API corresponding to the script related to deviceBrand exists, the user terminal (200) can return a brand such as "google," "samsung," or "apple" as an output value. Then, the user terminal (200) can send the returned output value as a response signal to an address defined in the library.

[0107] If the API corresponding to the command signal does not exist in the library (S151, No), the user terminal (200) can send an error signal to the command signal as a response signal to an address defined in the library (S153).

[0108] For example, an API corresponding to a script related to displaySize may be an API that checks the screen resolution of the user terminal 200. If there is no API corresponding to a script related to displaySize, the user terminal 200 may send an error signal as a response signal to an address defined in the library.

[0109] Based on the above-described configuration, the user terminal (200) can receive a command signal from the server (100). The command signal can include only a script for adding or changing items for collecting data. Therefore, the command signal can only read data from variables in the code of an application installed on the user terminal (200), without generating or changing the data. Therefore, even if the user terminal (200) receives a command signal from the server (100), it is possible to prevent problems from occurring in the installed application.

[0110] An example of a method for the server (100) to receive a response signal from the user terminal (200) will be described below.

[0111] FIG. 4 is a flowchart illustrating an example method for supporting server-performed data collection, according to embodiments of the present disclosure.

[0112] Referring to FIG. 4, the server (100) can receive a report signal regarding preparation for receiving a command from the user terminal (200) (S210).

[0113] Specifically, the user terminal 200 can access a pre-specified library in response to the execution of the target application. When the pre-specified library is accessed, the user terminal 200 can send a report signal regarding preparation for receiving a command to an address defined in the library. Thus, the server 100 can receive the report signal.

[0114] The server (100) can send a command signal defined in the first programming language in response to the report signal (S220). When the command signal is parsed by the user terminal (200), it can be generated as a command for checking whether an API corresponding to the command signal defined in the first programming language exists in the library.

[0115] For example, the server (100) can send a command signal to the user terminal (200) that is written in a scripting language or that includes a script.

[0116] According to one embodiment, the server (100) can determine whether a first tag item exists, which determines whether to collect tags from at least one tag item, based on user interaction input. If the first tag item exists, the server (100) can determine whether to collect a first trigger item included in the first tag item based on user interaction input. Also, if the first tag item exists, the server (100) can determine whether to collect a first variable item included in the first tag item based on user interaction input. The server (100) can generate a command signal based on the determination result.

[0117] For example, the server 100 may generate a command signal to collect a first tag item, a first trigger item, and a first variable item. As another example, the server 100 may generate a command signal to collect the first tag item. As yet another example, the server 100 may generate a command signal to collect the first tag item and the first trigger item. As yet another example, the server 100 may generate a command signal to collect the first tag item and the first variable item. As yet another example, the server 100 may generate a command signal to not collect the first tag item. In this case, a command signal may be generated so that the first trigger item and the first variable item are not collected either.

[0118] The server (100) can receive a response signal to the command signal from the user terminal (200) (S230).

[0119] For example, if an API corresponding to the command signal exists in the library of the user terminal (200), the server (100) can receive the output value returned by the user terminal (200) in response to the command signal as a response signal.

[0120] As another example, if the API corresponding to the command signal does not exist in the library of the user terminal (200), the server (100) can receive an error signal in response to the command signal.

[0121] FIG. 5 is a diagram illustrating an example of a method for supporting data collection performed by a server and a user terminal according to embodiments of the present disclosure.

[0122] Referring to Figure 5, a development company can plan an app. App can be an abbreviation for application. The development company can develop a program based on the plan. The development company can add code to the program as an SDK that starts a remote script system when the app is launched. The development company can build the app. When the app is built, all of the app's functions can be tested. If a bug exists based on the test results, the development company can fix the bug. Then, the development company can distribute the app.

[0123] Once the app is distributed, the user terminal (200) can install the app or apply patches from the market provided by the operating system. The user terminal (200) can use the app based on input from the user. The development company can receive data from the use of the app and review the app.

[0124] Development companies can decide what additional content to collect. Conventionally, when a developer decides to add content to be collected from the user terminal (200), they have had to go back to the program development (or program modification) stage and rebuild the program. Then, they have had to repeat the process of building, testing, fixing bugs, and distributing the app. On the other hand, with the method for supporting data collection based on the present disclosure, development companies can easily add content to be collected by adding script code to the remote settings.

[0125] Specifically, when the development company has decided on the additional collection content, it can add the script code to be collected to the remote settings. The development company can test the simple collection. Since there is no change to the application itself and only the value of the remote setting script is obtained, the simple collection test can be performed quickly. The development company can apply the script code in the remote settings. The user terminal (200) can receive the remote settings when the application is executed. Here, receiving the remote settings can mean that the additional collection content is applied as script code. Therefore, the user terminal (200) can collect the data added to the remote settings. Then, the user terminal (200) can send the collected data to the development company. The development company can review the added data collection content.

[0126] 6 is a diagram illustrating an example of at least one tag item according to embodiments of the present disclosure. This diagram does not illustrate a user interface provided by the server 100, but may be a diagram illustrating an example of at least one tag item.

[0127] Referring to FIG. 6, the at least one tag item may include a first tag item (410) and a second tag item (420).

[0128] The first tag item (410) may include a first trigger item (411) and a first variable item (412). The first tag item (410) may be selectively collected based on user interaction input. If it is determined that the first tag item (410) is to be collected, the first trigger item (411) and the first variable item (412) may be selectively collected based on user interaction input.

[0129] The second tag item (420) may include a second trigger item (421) and a second variable item (422). The second tag item (420) may be selectively collected based on user interaction input. If it is determined that the second tag item (420) is to be collected, the second trigger item (421) and the second variable item (422) may be selectively collected based on user interaction input.

[0130] In some embodiments of the present invention, the first tag item (410) may be a basic tag item using a predefined tag item, and the second tag item (420) may be a user-created tag item. That is, the at least one tag item may include at least one of a basic tag item and a user-created tag item.

[0131] A basic tag item can be an item incorporating a remote script created in advance by the developer of the server 100. A user-created tag item can be an item in which a remote script is created by a user who has purchased a program to execute the method for supporting data collection described above.

[0132] It is believed that the data collection requirements of companies developing similar applications are often similar. Therefore, the server (100) can provide basic tag items based on the typical requirements of each development company. However, even if the requirements are similar, not all development requirements are the same. Therefore, users can create their own tag items that suit their needs.

[0133] The description of the embodiments set forth herein is provided to enable any person skilled in the art to use or practice the present disclosure. Various modifications to the embodiments will be apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments without departing from the scope of the present disclosure. Therefore, the present disclosure is not intended to be limited by the embodiments set forth herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. 1. A method for supporting data collection in a user terminal including at least one processor, comprising: accessing a pre-specified library in response to execution of the target application; sending a report signal regarding readiness to receive a command to an address defined in the library; receiving a command signal defined in a first programming language; determining a response signal to the command signal according to whether an application programming interface (API) corresponding to the command signal exists; and transmitting the response signal to an address defined in the library.

2. In claim 1, The API corresponding to the command signal is: A method for supporting data collection defined in a second programming language corresponding to the operating system of the user terminal.

3. In claim 1, determining the response signal comprises: If an API corresponding to the command signal exists in the library, transmitting an output value defined in the API as the response signal to an address defined in the library; or A method for supporting data collection, comprising: if an API corresponding to the command signal does not exist in the library, sending an error signal for the command signal as the response signal to an address defined in the library.

4. In claim 1, determining a response signal to the command signal according to whether an API (application programming interface) corresponding to the command signal exists, parsing the command signal to generate a command; and Executing the generated command to determine whether an API exists in the library that corresponds to the command signal.

5. In claim 1, The command signal is at least one tag item specifying tags to collect; Each of the at least one tag item comprises: A method for supporting data collection, comprising a trigger item that sets a condition under which the tag item is executed, and a variable item that specifies the data to be collected.

6. In claim 5, The command signal is The at least one tag item is generated to be selectively collected based on a user interaction input corresponding to a pre-designated graphic object; A method for supporting data collection, wherein the pre-specified graphic objects include a first graphic object indicating collection instructions corresponding to a first tag item, a first-1 graphic object indicating execution instructions related to a trigger condition associated with the first tag item, and a first-2 graphic object indicating collection instructions for variables related to the first tag item.

7. In claim 6, determining a response signal to the command signal according to whether an API (application programming interface) corresponding to the command signal exists, determining whether a first tag item exists, for which it is determined to collect tags from among the at least one tag item based on the command signal; If the first tag item exists, determining whether to collect a first trigger item included in the first tag item based on the command signal; and If the first tag item exists, determining whether to collect each of the first variable items included in the first tag item based on the command signal.

8. In claim 5, The at least one tag item is: A method for supporting data collection that includes at least one of a basic tag term utilizing a predefined tag term and a user-created tag term.

9. 1. A method for supporting data collection in a server including at least one processor, comprising: receiving a report signal from the user terminal indicating readiness to receive a command; transmitting a command signal defined in a first programming language in response to the report signal; and receiving a response signal to said command signal from said user terminal.

10. In claim 9, receiving a response signal to the command signal from the user terminal, If an API corresponding to the command signal exists in a library of the user terminal, receiving an output value defined in the API as the response signal; or 10. A method for supporting data collection, comprising: receiving an error signal in response to the command signal if an API corresponding to the command signal does not exist in the library.

11. In claim 10, The API corresponding to the command signal is: A method for supporting data collection defined in a second programming language corresponding to the operating system of the user terminal.

12. In claim 10, The command signal is A method for supporting data collection, wherein when parsed by the user terminal, a command is generated to confirm whether an API corresponding to a command signal defined in the first programming language exists in the library.

13. In claim 9, The command signal is at least one tag item specifying tags to collect; Each of the at least one tag item comprises: A method for supporting data collection, comprising a trigger item that sets a condition under which the tag item is executed, and a variable item that specifies the data to be collected.

14. In claim 13, The command signal is The at least one tag item is generated to be selectively collected based on a user interaction input corresponding to a pre-designated graphic object; A method for supporting data collection, wherein the pre-specified graphic objects include a first graphic object indicating collection instructions corresponding to a first tag item, a first-1 graphic object indicating execution instructions related to a trigger condition associated with the first tag item, and a first-2 graphic object indicating collection instructions for variables related to the first tag item.

15. In claim 14, transmitting a command signal defined in a first programming language in response to the report signal, determining whether a first tag item exists, the first tag item being determined to collect tags from the at least one tag item based on the user interaction input; If the first tag item exists, determining whether to collect a first trigger item included in the first tag item based on the user interaction input; and If the first tag item exists, a step of determining whether to collect data for each first variable item included in the first tag item based on the user interaction input.

16. In claim 15, The at least one tag item is: A method for supporting data collection that includes at least one of a basic tag term utilizing a predefined tag term and a user-created tag term.

Images