Methods 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] This disclosure relates to a method for supporting data collection, specifically to a method for supporting data collection on user terminals.

Background Art

[0002] The process of distributing an app for the Android operating system can be briefly summarized as follows.

[0003] Application development: First, it is necessary to develop an app that runs on a user terminal. This process may include designing the user interface, implementing the app's logic, testing, etc.

[0004] Application build: Once the app development is complete, it is necessary to build the app. Building refers to the process of compiling the source code and packaging it into an APK (Android Package) file.

[0005] Signing: It is necessary to sign the app. Adding a signature to the APK file makes the app recognized as a trustworthy source. For signing, it is possible to use a debug keystore for development or a keystore for release, etc.

[0006] Google Play Console registration: To distribute the app on the Google Play Store, it is necessary to register on the Google Play Console. This enables setting app information, price, description, screenshots, version management, etc.

[0007] Uploading an APK: Upload your APK file via the Google Play Console. You can upload a release APK file or set up various release tracks such as Alpha, Beta, and Production.

[0008] Resource and Store Page Settings: Configure resources such as the app icon, graphic assets, description, and app store page.

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

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

[0011] Application Distribution: Once the review is complete, the app will be distributed to the Google Play Store. Users will be able to search for and download the app from the store.

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

[0013] User Support and Feedback Management: Manage communication with users of the app, process feedback and problem reports, and contribute to improving the app.

[0014] Marketing and Public Relations: After successfully launching the app, we will promote it and secure more users through marketing and publicity activities.

[0015] Android applications developed as native apps typically require following the distribution process described above to reflect the application's content. The development, build, testing, and distribution process is time-consuming and resource-intensive, and even when updating the application, the development, build, and testing processes are still necessary. Furthermore, remote resource patching methods have limitations because they cannot change the executing entity. [Overview of the Initiative] [Problems that the invention aims to solve]

[0016] This disclosure was devised in response to the aforementioned background technology and aims to provide a method for supporting data collection on user terminals that allows the items of data collected to be changed without rebuilding or redistributing the application.

[0017] The technical challenges described in this disclosure are not limited to those mentioned above, and those skilled in the art can clearly understand challenges other than those mentioned above based on the following description. [Means for solving the problem]

[0018] A method for supporting data collection in a user terminal including at least one processor is disclosed based on one embodiment of the present disclosure for solving the aforementioned problems. The method for supporting data collection in the user terminal may include the steps of: accessing a pre-specified library in response to the 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 the existence of an API (application programming interface) corresponding to the command signal; and sending the response signal to an address defined in the library.

[0019] Furthermore, the API corresponding to the above command signals can be defined using a second programming language corresponding to the operating system of the user terminal.

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

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

[0022] Furthermore, the command signal may include at least one tag item that specifies the tags 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 signals are generated based on user interaction input corresponding to a pre-specified graphic object, such that at least one tag item is selectively collected. The pre-specified graphic object may include a first graphic object indicating a collection command corresponding to a first tag item, a 1-1 graphic object indicating an execution command related to a trigger condition associated with the first tag item, and a 1-2 graphic object indicating a collection command for a variable related to the first tag item.

[0024] Furthermore, depending on the existence of an API (application programming interface) corresponding to the above command signal, the step of determining the response signal to the above command signal may include the steps of determining whether or not there is a first tag item from which it has been decided to collect a tag based on the above command signal; if the above first tag item exists, determining whether or not to collect a first trigger item included in the above first tag item based on the above command signal; and if the above first tag item exists, determining whether or not to collect a first variable item included in the above first tag item based on the above command signal.

[0025] Furthermore, each of the above-mentioned tag items may include at least one of the following: a basic tag item that utilizes a default tag item, and a tag item created by the user.

[0026] A method for supporting data collection in a server including at least one processor, the method including receiving a reporting signal regarding command reception preparation from a user terminal, transmitting a command signal defined by a first programming language as a response to the reporting signal, and receiving a response signal to the command signal from the user terminal.

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

[0028] Also, the API corresponding to the command signal may be defined by a second programming language corresponding to the operating system of the user terminal.

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

[0030] Also, the command signal includes at least one tag item specifying tags to be collected, and each of the at least one tag item may include a trigger item for setting conditions under which the tag item is executed and a variable item for specifying data to be collected.

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

[0032] Furthermore, the step of sending a command signal defined in a first programming language in response to the above-mentioned reporting signal may include, based on the input of the above-mentioned user interaction, determining whether or not there is a first tag item from which it has been decided to collect a tag from among the at least one tag item; if the above-mentioned first tag item exists, determining whether or not to collect a first trigger item included in the above-mentioned first tag item based on the input of the above-mentioned user interaction; and if the above-mentioned first tag item exists, determining whether or not to collect a first variable item included in the above-mentioned first tag item based on the input of the above-mentioned user interaction.

[0033] Furthermore, each of the above-mentioned tag items may include at least one of the following: a basic tag item that utilizes a default tag item, and a tag item created by the user.

[0034] The technical solutions derived from this disclosure are not limited to those described above, and a person with ordinary skill in the art to which this disclosure belongs can clearly understand solutions other than those described above from the following description. [Effects of the Invention]

[0035] Based on several embodiments of this disclosure, it is possible to provide a method for easily changing the items from which data is collected without rebuilding or redistributing the application.

[0036] The effects derived from this disclosure are not limited to those described above. A person with ordinary skill in the art to which this disclosure belongs can clearly understand, based on the following description, effects other than those described above.

[0037] Various aspects will be described with reference to the drawings. In the following descriptions of the drawings, similar drawing numbers are used to indicate generally similar components. In the following embodiments, for illustrative purposes, numerous specific details are provided to aid in the overall understanding of one or more aspects. However, it is evident that such (or more) aspects can be implemented without such specific details. In other examples, known structures and devices are illustrated in block diagrams to facilitate the description of one or more aspects. [Brief explanation of the drawing]

[0038] [Figure 1] This disclosure provides an exemplary system for performing a method to support data collection, based on several embodiments described herein. [Figure 2] This flowchart illustrates an example of a method for supporting data collection performed by a user terminal, based on several embodiments of this disclosure. [Figure 3] This flowchart illustrates an example of how a user terminal transmits a response signal, based on several embodiments of this disclosure. [Figure 4] This flowchart illustrates an example of a method for supporting data collection performed by a server, based on several embodiments of this disclosure. [Figure 5] This diagram illustrates an example of a method for supporting data collection performed by a server and a user terminal, based on several embodiments of this disclosure. [Figure 6] This is a drawing illustrating an example of at least one tag item based on multiple embodiments of this disclosure. [Modes for carrying out the invention]

[0039] The present invention is subject to various modifications and can have multiple embodiments. Specific embodiments are shown with reference to the drawings and described in detail in the [Detailed Description of the Invention]. However, this should not be understood as limiting the present invention to specific embodiments, but rather as including all modifications, equivalents, or substitutes that fall within the spirit and technical scope of the present invention. In describing each drawing, similar reference numerals are used for similar components.

[0040] The terms First, Second, A, B, etc., are used to describe various components, but the components should not be limited by these terms. The terms are used solely for the purpose of distinguishing one component from another. Accordingly, without departing from the scope of the present invention, the First component may be named the Second component, and similarly, the Second component may be named the First component. The terms "and / or" include any combination of multiple related descriptions or any one of multiple related descriptions.

[0041] When one component is described as being "connected," "linked," or "connected" to another component, it should be understood that while it is possible for it to be directly connected, linked, or connected to the other component, other components may also exist in between. On the other hand, when one component is described as being "directly connected," "directly linked," or "directly connected" to another component, it should be interpreted that no other components exist in between.

[0042] The terms used in this application are used to describe specific embodiments and are not intended to limit the invention. Singular expressions are to be understood as including plural expressions unless the context clearly indicates otherwise. In this application, terms such as “include,” “contain,” “have,” or “possess” should be understood as indicating the existence of features, figures, stages, operations, components, parts, or combinations thereof described in the specification, and not as presupposing the possibility of the existence or addition of one or more other features, figures, stages, operations, components, parts, or combinations thereof.

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

[0044] In this disclosure, a user terminal can receive command signals from a server. Here, the command signals can be scripts, etc. The scripts can be programming languages ​​that can be executed without compiling the source code. The user terminal can send response signals to the server corresponding to the received command signals. Therefore, the server's user can collect data from the user terminal without rebuilding or redistributing the application.

[0045] The following describes how to support data collection performed by a user terminal using Figures 1 to 3, and how to support data collection performed by a server using Figure 4.

[0046] Figure 1 shows an exemplary system for performing a method to support data collection, based on several embodiments of this disclosure.

[0047] Referring to Figure 1, a system for implementing a method to support data collection may include a server (100), user terminals (200), and a network (300).

[0048] The server (100) may include any type of computer system or computer device, such as a microprocessor, mainframe computer, digital processor, portable device, or device controller.

[0049] A server (100) can achieve desired system performance by using a combination of typical computer hardware (for example, a computer processor, memory, storage, input and output devices, and other components of conventional computing devices, 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., a set of commands that make the computing device function in a specific way).

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

[0051] The processor (110) is capable of handling the general operation of the server (100). The processor (110) can provide or process appropriate information or functions to the user by processing signals, data, information, etc. that are input or output through the components of the server (100), or by driving application programs stored in the storage unit.

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

[0053] The storage unit may include memory and / or a persistent storage medium. The memory may include at least one type of storage medium from among flash memory type, hard disk type, multimedia card micro type, card type memory (e.g., SD or XD memory), RAM (Random Access Memory), SRAM (Static Random Access Memory), ROM (Read-Only Memory), EEPROM (Electrically Erasable Programmable Read-Only Memory), PROM (Programmable Read-Only Memory), 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 the communication system, between the server (100) and the user terminal (200), or between the server (100) and the network (300).

[0055] In this disclosure, the server (100) can send command signals to the user terminal (200). Command signals 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 the source code. When a 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). The method for supporting data collection performed by the server (100) will be explained below with reference to Figure 4.

[0056] A user terminal (200) can achieve desired system performance by using a combination of typical computer hardware (e.g., a computer processor, memory, storage, input and output devices, and other components of conventional computing devices, 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., a set of commands that make the computing device function in a specific way). A user terminal (200) can include a personal computer (PC), notebook computer, mobile terminal, smartphone, tablet PC, etc., owned by the user, and can include all types of terminals that can connect to a wired / wireless network.

[0057] In this disclosure, a user terminal (200) is capable of transmitting a response signal to a command signal received from a server (100). The response signal may include data collected by the user terminal (200). An example of how the user terminal (200) transmits a response signal to a command signal received from a server (100) will be described below with reference to Figures 2 and 3.

[0058] A network (300) can be a closed network such as a LAN (Local Area Network) or a WAN (Wide Area Network), or an open network such as the Internet. The Internet refers to a global open computer network structure that provides the TCP / IP protocol and all services that exist on its upper layers, namely HTTP (HyperText Transfer Protocol), Telnet, FTP (File Transfer Protocol), DNS (Domain Name System), SMTP (Simple Mail Transfer Protocol), SNMP (Simple Network Management Protocol), NFS (Network File Service), and NIS (Network Information Service).

[0059] The following describes an example of how to support data collection performed by the user terminal (200).

[0060] Figure 2 is a flowchart illustrating an example of a method for supporting data collection performed by a user terminal, based on several embodiments of this disclosure.

[0061] Referring to Figure 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 can be an application pre-distributed for data collection. The target application can also be an application installed via an SDK (Software Development Kit) in library format. When the target application is executed based on user input, the user terminal (200) can access pre-specified libraries.

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

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

[0065] For example, a command signal can include scripts related to deviceBrand, displaySize, and view("Button").text.

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

[0067] Specifically, a command signal can include at least one of the following: at least one tag item, a trigger item, and a variable item. Trigger items and variable items can be sub-components of at least one tag item. In other words, at least one tag item can contain trigger items and variable items.

[0068] Tag fields allow you to specify the items to be collected.

[0069] For example, tag items can specify items to be collected, such as button clicks, specific key clicks, specific item clicks or touches, or specific item touches.

[0070] Trigger items allow you to set conditions under which tag items are executed.

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

[0072] As another example, a trigger item can be an item that triggers data collection when certain data changes.

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

[0074] In several embodiments of this disclosure, command signals can be generated such that at least one tag item is selectively collected based on the input of a user interaction corresponding to a pre-specified graphic object. Here, the user interaction can be an interaction performed between a server (100) and a user of the server (100).

[0075] Specifically, each of at least one tag item can correspond to each of at least one graphic object. Assuming that a first tag item exists within at least one tag item, a first graphic object corresponding to the first tag item can exist. Command signals can be generated to selectively collect the first tag item in response to user interaction with the first graphic object.

[0076] For example, a command signal can be generated in response to a user interaction with a first graphic object to collect a first tag item. Alternatively, a command signal can be generated in response to a user interaction with a first graphic object to *not* collect a first tag item.

[0077] A pre-specified graphic object may include a first graphic object that shows a collection command corresponding to a first tag item, a first-first graphic object that shows an execution command related to a trigger condition associated with the first tag item, and a first-second graphic object that shows a collection command for a variable associated with the first tag item. The first-first and first-second graphic objects may be subordinate objects of the first graphic object.

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

[0079] For example, a command signal can be generated to collect the first trigger item in response to a user interaction with the first graphic object. Alternatively, a command signal can be generated not to collect the first trigger item in response to a user interaction with the first graphic object.

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

[0081] For example, a command signal can be generated to collect the first variable item in response to a user interaction with the first-to-second graphic object. Alternatively, a command signal can be generated to *not* collect the first variable item in response to a user interaction with the first-to-second graphic object.

[0082] The user terminal (200) can determine a response signal to a 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 a command signal, whether or not there exists a first tag item from which it has been determined to collect tags from at least one other tag item. If a first tag item exists, the user terminal (200) can determine, based on a command signal, whether or not to collect the first trigger item included in the first tag item. Furthermore, if a first tag item exists, the user terminal (200) can determine, based on a command signal, whether or not to collect the first variable item included in the first tag item.

[0084] For example, based on a command signal, the user terminal (200) can collect items related to the first tag item if the first tag item exists. The user terminal (200) can collect items such as button clicks, specific key clicks, specific item clicks, touches, or touches of specific items related to the first tag item. To give another example, based on a command signal, if the user terminal (200) has decided to collect tags from at least one tag item, but the first tag item does not exist, it can choose not to collect items related to the first tag item.

[0085] If it is decided that the first trigger item will be collected, the user terminal (200) can collect data from the occurrence of actions such as clicking a button, clicking a specific key, clicking or touching a specific item, or touching a specific item, related to the first trigger item.

[0086] If it is decided that the user terminal (200) will collect the first variable item, it will be able to collect specific data of a specific class related to the first variable item.

[0087] The user terminal (200) can parse command signals and generate commands. Parsing can be the operation of generating commands by breaking down the constituent components of a statement and determining the hierarchical relationships of the decomposed components. 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 or not an API corresponding to the command signal exists in the library. Here, the API can be an interface defined by a second programming language corresponding to the operating system of the user terminal (200).

[0088] For example, the user terminal (200) could be an Android-based device. In this case, the API could be an interface defined by a programming language corresponding to the Android operating system.

[0089] To give another example, the user terminal (200) could be an iOS-based device. In this case, the API could be an interface defined by a programming language corresponding to the iOS operating system.

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

[0091] For example, if a user terminal (200) has an API in the library that corresponds to a command signal, it can send an output value defined in the API as a response signal.

[0092] As another example, if the user terminal (200) does not have an API in the library that corresponds to a command signal, it can send an error signal as a response signal. Below, an example of how the user terminal (200) sends a response signal is explained using Figure 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 on which the server (100) can receive the response signal. The address defined in the library can be an address on 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 specified by the user of the server (100).

[0094] For example, a command signal can include scripts related to deviceBrand, displaySize, and view("Button").text.

[0095] The API corresponding to the script related to deviceBrand can be an API that verifies the brand of the user device (200). The user device (200) can return a brand such as "google", "samsung", or "apple" through the above 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" or "3036" through the above API.

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

[0098] The API corresponding to the `.text` query can be an instance or a text object. The above API 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 configuration described above, the user terminal (200) can receive command signals from the server (100). The user terminal can send data related to the command signals as response signals to the server (100) or an address defined in the library. The command signals can be signals that do not require the 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 this disclosure, the user terminal (200) can determine a response signal based on whether or not an API corresponding to a command signal exists in the library. Below, an example of how the user terminal (200) transmits a response signal according to this disclosure will be explained with reference to Figure 3.

[0102] Figure 3 is a flowchart illustrating an example of how a user terminal transmits a response signal, based on several embodiments of this disclosure.

[0103] Referring to Figure 3, the user terminal (200) can determine whether or not an API corresponding to a command signal exists within the library.

[0104] If an API corresponding to a 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 the address defined in the library (S152).

[0105] For example, a command signal can include scripts related to deviceBrand, displaySize, and view("Button").text.

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

[0107] If there is no API in the library that corresponds to the command signal (S151, no), the user terminal (200) can send an error signal for the command signal as a response signal to an address defined in the library (S153).

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

[0109] Based on the configuration described above, the user terminal (200) can receive command signals from the server (100). Command signals can only contain scripts for adding or modifying items from which data is collected. Therefore, command signals can be read without generating or modifying data from variables in the code of applications installed on the user terminal (200). Thus, even if the user terminal (200) receives command signals from the server (100), it is possible to ensure that no problems occur in the installed applications.

[0110] The following describes an example of how a server (100) receives a response signal from a user terminal (200).

[0111] Figure 4 is a flowchart illustrating an example of a method for supporting data collection performed by a server, based on several embodiments of this disclosure.

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

[0113] Specifically, the user terminal (200) can access a pre-specified library in response to the execution of the target application. When the user terminal (200) accesses the pre-specified library, it can send a report signal indicating readiness to receive a command to an address defined in the library. Therefore, the server (100) can receive the report signal.

[0114] The server (100) can send a command signal defined in a first programming language as a response to a report signal (S220). If the command signal is parsed by the user terminal (200), 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.

[0115] For example, a server (100) can send command signals, which are written in a scripting language or contain scripts, to a user terminal (200).

[0116] In one embodiment, the server (100) can determine, based on user interaction input, whether or not there exists a first tag item from which it has been decided to collect a tag from at least one tag item. If a first tag item exists, the server (100) can determine, based on user interaction input, whether or not to collect a first trigger item included in the first tag item. Furthermore, if a first tag item exists, the server (100) can determine, based on user interaction input, whether or not to collect a first variable item included in the first tag item. Based on the determination result, the server (100) can generate a command signal.

[0117] For example, the server (100) can generate a command signal to collect the first tag item, the first trigger item, and the first variable item. As another example, the server (100) can generate a command signal to collect the first tag item. Another example is that the server (100) can generate a command signal to collect the first tag item and the first trigger item. Yet another example is that the server (100) can generate a command signal not to collect the first tag item. In this case, the command signal can also be generated so that the first trigger item and the first variable item are not collected.

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

[0119] For example, if an API corresponding to a command signal exists in the user terminal's (200) library, 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] To give another example, if the server (100) does not have an API corresponding to the command signal in the user terminal's (200) library, it can receive an error signal as a response signal for the command signal.

[0121] Figure 5 is a diagram illustrating an example of a method for supporting data collection performed by a server and a user terminal, based on several embodiments of this disclosure.

[0122] Referring to Figure 5, a development company can plan an app. "App" can be an abbreviation for "application." Based on the plan, the development company can develop the program. The development company can add code to start the remote scripting system as an SDK into the program 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. Based on the test results, the development company can fix any bugs that exist. Finally, the development company can distribute the app.

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

[0124] The development company can decide what additional data to collect. Traditionally, if they decided to collect additional data from the user terminal (200), they had to go back to the program development (or program modification) stage and rebuild the program. Then, they had to repeat the process of building, testing, bug fixing, and distributing the app. On the other hand, with the method of supporting data collection under this disclosure, the development company can easily add the data to be collected by adding the script code to be collected to the remote configuration.

[0125] Specifically, once the development company has decided on the additional data to be collected, it can add the script code for collection to the remote configuration. The development company can then test a simplified data collection. Since this test does not involve any changes to the application itself and only requires obtaining values ​​from the remote configuration script, it can be performed quickly. The development company can then apply the script code to the remote configuration. The user terminal (200) can receive the remote configuration when the application is executed. Receiving the remote configuration here means that the additional data to be collected is applied as script code. As a result, the user terminal (200) can collect the data added to the remote configuration. The user terminal (200) can then send the collected data to the development company. The development company can then review the content of the added data collection.

[0126] Figure 6 is a diagram illustrating an example of at least one tag item based on several embodiments of this disclosure. Figure 6 may be a diagram illustrating an example of at least one tag item, rather than showing a user interface provided by the server (100).

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

[0128] The first tag item (410) may contain the first trigger item (411) and the first variable item (412). The first tag item (410) may be selectively collected based on user interaction input. If it is decided that the first tag item (410) will 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 contain 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 decided that the second tag item (420) will be collected, the second trigger item (421) and the second variable item (422) may be selectively collected based on user interaction input.

[0130] In several embodiments of the present invention, the first tag item (410) can be a basic tag item using a default tag item. The second tag item (420) can be a user-created tag item. In other words, at least one tag item can include at least one of the basic tag item and the user-created tag item.

[0131] Basic tag items can be items that incorporate remote scripts created in advance by the server (100) development company, etc. User-created tag items can be items for which remote scripts have been created by users who have purchased a program to perform the aforementioned data collection support method.

[0132] It is likely that multiple applications of similar types will often have similar data collection requirements from the companies developing them. Therefore, the server (100) can provide basic tag items based on the typical requirements of each development company. However, even though requirements may be similar, not all development requirements are identical. Therefore, users can generate user-created tag items that suit their needs.

[0133] The descriptions relating to the embodiments presented herein are provided so that any person with ordinary skill in the art of this disclosure may utilize or implement the disclosure. Various variations of such embodiments are readily apparent to a person with ordinary skill in the art of this disclosure, and the general principles defined herein can be applied to other embodiments without departing from the scope of this disclosure. Accordingly, this disclosure is not limited by the embodiments presented herein, but should be interpreted in the broadest sense consistent with the principles and novel features presented herein.

Claims

1. A method for supporting data collection in a user terminal including at least one processor, In response to the execution of the target application, the process involves accessing a pre-specified library. In the step of sending a report signal regarding preparation for receiving a command to the address defined in the aforementioned library, The step of receiving a command signal defined by the first programming language, A 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, and A method for supporting data acquisition, comprising the step of transmitting the response signal to an address defined in the library.

2. In claim 1, The API corresponding to the aforementioned 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, The step of determining the response signal is: If an API corresponding to the command signal exists in the library, the output value defined in the API is sent as the response signal to the address defined in the library, or A method for supporting data acquisition, which includes the step of sending an error signal for the command signal to an address defined in the library as the response signal if an API corresponding to the command signal does not exist in the library.

4. In claim 1, The step of determining the response signal to the command signal, depending on the presence or absence of an API (application programming interface) corresponding to the command signal, is as follows: The steps of parsing the command signal and generating a command, and A method for supporting data acquisition, comprising the step of executing a generated command and determining whether or not an API corresponding to the command signal exists in the library.

5. In claim 1, The aforementioned command signal is Includes at least one tag field that specifies the tags to collect, Each of the above at least one tag item is: A method for supporting data collection, including a trigger item that sets the conditions under which the aforementioned tag item is executed, and a variable item that specifies the data to be collected.

6. In claim 5, The aforementioned command signal is Based on user interaction input corresponding to a pre-specified graphic object, at least one tag item is generated so that it is selectively collected. A method for supporting data collection, wherein the pre-specified graphic objects include a first graphic object indicating a collection command corresponding to a first tag item, a first-first graphic object indicating an execution command relating to a trigger condition associated with the first tag item, and a first-second graphic object indicating a collection command for a variable relating to the first tag item.

7. In claim 6, The step of determining the response signal to the command signal, depending on the presence or absence of an API (application programming interface) corresponding to the command signal, is as follows: Based on the command signal, a step is to determine whether or not there is a first tag item for which it has been decided to collect a tag from among the at least one tag item. If the first tag item exists, the step of determining whether or not to collect the first trigger item included in the first tag item based on the command signal, and A method for supporting data collection, comprising the step of determining, based on the command signal, whether or not to collect each of the first variable items included in the first tag item if the first tag item exists.

8. In claim 5, The aforementioned at least one tag item is, A method for supporting data collection that includes at least one of the following: a basic tag field that uses a default tag field, and a tag field created by the user.

9. A method for supporting data collection in a server including at least one processor, The stage in which a report signal indicating readiness to receive commands is received from the user terminal. The steps include transmitting a command signal defined by a first programming language in response to the aforementioned report signal, and The step includes receiving a response signal to the command signal from the user terminal, The aforementioned command signal is Includes at least one tag field that specifies the tags to collect, Each of the above at least one tag item is: A method for supporting data collection, which includes a trigger item that sets the conditions under which the aforementioned tag item is executed, and a variable item that specifies the data to be collected.

10. In claim 9, The step of receiving a response signal to the command signal from the user terminal is: If an API corresponding to the command signal exists in the user terminal's library, the process involves receiving the output value defined in the API as the response signal, or A method for supporting data acquisition, which includes the 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.

11. In claim 10, The API corresponding to the aforementioned 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 aforementioned command signal is A method for supporting data collection, wherein, when parsed by the user terminal, a command is generated to check whether an API corresponding to a command signal defined in the first programming language exists within the library.

13. In claim 9, The aforementioned command signal is Based on user interaction input corresponding to a pre-specified graphic object, at least one tag item is generated so that it is selectively collected. A method for supporting data collection, wherein the pre-specified graphic objects include a first graphic object indicating a collection command corresponding to a first tag item, a first-first graphic object indicating an execution command relating to a trigger condition associated with the first tag item, and a first-second graphic object indicating a collection command for a variable relating to the first tag item.

14. In claim 13, The step of transmitting a command signal defined by a first programming language in response to the aforementioned report signal is: Based on the input of the user interaction, it is decided to collect tags from among the at least one tag item, in the step of determining whether or not a first tag item exists. If the first tag item exists, the step of deciding whether or not to collect the first trigger item included in the first tag item based on the input of the user interaction, and A method for supporting data collection, which includes, if the first tag item exists, determining whether or not to collect data for each of the first variable items included in the first tag item based on the input of the user interaction.

15. In claim 14, The aforementioned at least one tag item is, A method for supporting data collection that includes at least one of the following: a basic tag field that uses a default tag field, and a tag field created by the user.

Images