Method for supporting data collection

Abstract

According to some embodiments of the present disclosure, a method for supporting data collection for a user terminal including at least one processor is disclosed. The method for supporting data collection for a user terminal comprises the steps of: accessing a pre-designated library in response to the execution of a target application; transmitting a report signal for instruction reception preparation to an address defined in the library; receiving an instruction signal defined in a first programming language; determining a response signal to the instruction signal according to whether an application programming interface (API) corresponding to the instruction signal is present; and transmitting the response signal to the address defined in the library.

Description

How to support data collection

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

[0002] The process of deploying an app on the Android operating system can be summarized as follows:

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

[0004] Building the application: Once app development is complete, you need to build the app. Building can refer to the process of compiling the source code and packaging it into an APK (Android Package) file.

[0005] Signing: Apps must be signed. Adding a signature to an APK file ensures that the app is recognized as a trusted source. You can use a development debug keystore or a release keystore for signing.

[0006] Register with the Google Play Console: To distribute your app to the Google Play Store, you must register with the Google Play Console. This allows you to configure your app information, pricing, description, screenshots, version control, and more.

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

[0008] Set up resources and store pages: Set up resources such as app icons, graphic materials, descriptions, and app store pages.

[0009] Pricing and Country Settings: Set your app's price and specify which countries it will be available in. You can choose whether your app is free or paid, and manage your pricing policy.

[0010] Release and Review: Release your app on the Google Play Console and it will undergo Google's review process. This review verifies the app's content, compliance with advertising policies, and more.

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

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

[0013] User Support and Feedback Management: Manage interactions with users using your app, process feedback and issue reports, and contribute to app improvement.

[0014] Marketing and Promotion: After successfully deploying your app, you'll need to engage more users and promote it through marketing and promotion activities.

[0015] Natively developed Android applications typically must follow the deployment process described above to reflect application content. The entire process of development, build, testing, and deployment consumes significant time and resources. Even using application updates, the development, build, and testing process is still necessary. Furthermore, remote resource patching methods cannot change the execution entity, limiting the scope of changes.

[0016] The present disclosure is conceived in response to the aforementioned background technology, and seeks to provide a method for supporting data collection for a user terminal that allows changes to items for data collection without rebuilding or redistributing the application.

[0017] The technical problems of the present disclosure are not limited to the technical problems mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art from the description below.

[0018] According to one embodiment of the present disclosure for solving the above-described problem, a method for supporting data collection for a user terminal including at least one processor is disclosed. The method for supporting data collection for the user terminal may include: accessing a pre-designated library in response to execution of a target application; transmitting a report signal for command reception readiness 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 transmitting the response signal to an address defined in the library.

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

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

[0021] In addition, the step of determining a response signal to the command signal depending on whether an application programming interface (API) 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 an API corresponding to the command signal exists in the library.

[0022] Additionally, the command signal may include at least one tag item specifying a tag to be collected, and each of the at least one tag item may include a trigger item that sets a condition for executing the tag item and a variable item specifying data to be collected.

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

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

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

[0026] In addition, a method for supporting data collection for a server including at least one processor may include: receiving a report signal for command reception readiness from a user terminal; 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] In addition, 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 when an API corresponding to the command signal exists in a library of the user terminal; or a step of receiving an error signal in response to the command signal when an API corresponding to the command signal does not exist in the library.

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

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

[0030] Additionally, the command signal may include at least one tag item specifying a tag to be collected, and each of the at least one tag item may include a trigger item that sets a condition for executing the tag item and a variable item specifying data to be collected.

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

[0032] In addition, the step of transmitting a command signal defined in a first programming language in response to the report signal may include: determining whether a first tag item determined to collect a tag among the at least one tag item exists 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, 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 item may include at least one of a basic tag item using a predefined tag item and a user-created tag item.

[0034] The technical solutions obtainable in the present disclosure are not limited to the solutions mentioned above, and other solutions not mentioned will be clearly understood by a person having ordinary skill in the art to which the present disclosure pertains from the description below.

[0035] Some embodiments of the present disclosure provide a method for conveniently changing items for collecting data without rebuilding or redeploying the application.

[0036] The effects that can be obtained from the present disclosure are not limited to the effects mentioned above, and other effects that are not mentioned will be clearly understood by a person having ordinary skill in the art to which the present disclosure pertains from the description below.

[0037] Various aspects are now described with reference to the drawings, wherein like reference numerals are used to refer to similar elements generally. In the following examples, for purposes of explanation, numerous specific details are set forth to provide a thorough understanding of one or more aspects. However, it will be apparent that such aspects may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form to facilitate the description of one or more aspects.

[0038] FIG. 1 illustrates an exemplary system for performing a method for supporting data collection according to some embodiments of the present disclosure.

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

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

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

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

[0043] FIG. 6 is a diagram illustrating an example of at least one tag item according to some embodiments of the present disclosure.

[0044] The present invention is susceptible to various modifications and embodiments. Specific embodiments are illustrated in the drawings and described in detail in the detailed description. However, this is not intended to limit the present invention to specific embodiments, but rather to encompass all modifications, equivalents, and alternatives falling within the spirit and technical scope of the present invention. Throughout the description of each drawing, similar reference numerals have been used to designate similar components.

[0045] Terms such as "first," "second," "A," and "B" may be used to describe various components, but the components should not be limited by these terms. These terms are used solely to distinguish one component from another. For example, without departing from the scope of the present invention, the first component may be referred to as the "second component," and similarly, the second component may also be referred to as the "first component." The term "and / or" includes a combination of a plurality of related items described herein or any of a plurality of related items described herein.

[0046] When a component is referred to as being "connected" or "connected" to another component, it should be understood that it may be directly connected or connected to that other component, but that there may be other components intervening. Conversely, when a component is referred to as being "directly connected" or "connected" to another component, it should be understood that there are no other components intervening.

[0047] The terminology used in this application is only used to describe specific embodiments and is not intended to limit the present invention. The singular expression includes the plural expression unless the context clearly indicates otherwise. In this application, it should be understood that the terms "comprise" or "have" indicate the presence of a feature, number, step, operation, component, part, or combination thereof described in the specification, but do not exclude in advance the possibility of the presence or addition of one or more other features, numbers, steps, operations, components, parts, or combinations thereof.

[0048] Unless otherwise defined, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. Terms defined in commonly used dictionaries should be interpreted as having a meaning consistent with their meaning in the context of the relevant technology, and will not be interpreted in an idealized or overly formal sense unless explicitly defined herein.

[0049] In the present disclosure, a user terminal can receive a command signal from a server. The command signal may be a script, etc. The script may be a programming language capable of executing without compiling the source code. The user terminal can transmit a response signal corresponding to the received command signal to the server. Accordingly, the server user can collect data from the user terminal without rebuilding or redeploying the application.

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

[0051] FIG. 1 illustrates an exemplary system for performing a method for supporting data collection according to some embodiments of the present disclosure.

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

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

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

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

[0056] The control unit can typically handle the overall operation of the server (100). The control unit can process signals, data, information, etc. input or output through components of the server (100) or run application programs stored in the storage unit, thereby providing or processing appropriate information or functions to the user.

[0057] The control unit may be composed of 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).

[0058] The storage unit may include memory and / or a permanent storage medium. The memory may include at least one type of storage medium among a flash memory type, a hard disk type, a multimedia card micro type, a card type memory (e.g., SD or XD memory, etc.), a random access memory (RAM), a static random access memory (SRAM), a read-only memory (ROM), an electrically erasable programmable read-only memory (EEPROM), a programmable read-only memory (PROM), a magnetic memory, a magnetic disk, and an optical disk.

[0059] 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).

[0060] In the present disclosure, the server (100) can transmit 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 script language. The script language can be a programming language that can be executed without compiling the source code. When the command signal is received, the user terminal (200) can transmit a response signal to the server (100) using an application programming interface (API) corresponding to the command signal. Accordingly, the server (100) can collect data from the user terminal (200). Hereinafter, a method for supporting data collection performed by the server (100) will be described with reference to FIG. 4.

[0061] A user terminal (200) may achieve desired system performance by using a combination of typical computer hardware (e.g., devices that may include a computer processor, memory, storage, input devices and output devices, and other components of conventional computing devices; electronic communication devices such as routers, switches, etc.; 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) may include a personal computer (PC), notebook, mobile terminal, smart phone, tablet PC, etc. owned by the user, and may include all types of terminals that can connect to wired / wireless networks.

[0062] In the present disclosure, a user terminal (200) can transmit a response signal to a command signal received from a server (100). The response signal may include data collected by the user terminal (200). Hereinafter, an example of a method in which the user terminal (200) transmits a response signal to a command signal received from the server (100) will be described with reference to FIGS. 2 and 3.

[0063] The network (300) may 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. The Internet refers to a global open computer network structure that provides various services existing in the TCP / IP protocol and its upper layer, namely, Hyper Text 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).

[0064] Below, an example of a method for supporting data collection performed by a user terminal (200) is described.

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

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

[0067] The target application may be a pre-deployed application for data collection. The target application may be an application with a Software Development Kit (SDK) installed in the form of a library. When the target application is executed based on user input, the user terminal (200) can access a pre-designated library.

[0068] The user terminal (200) can transmit a report signal regarding readiness for command reception to an address defined in the library (S120). Here, the address defined in the library may be an address from which the server (100) can receive the report signal.

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

[0070] For example, a command signal might contain scripts related to deviceBrand, displaySize, and view("Button").text.

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

[0072] Specifically, the command signal may include at least one tag item, at least one trigger item, and at least one variable item. The trigger item and the variable item may be subcomponents of at least one tag item. In other words, at least one tag item may include a trigger item and a variable item.

[0073] Tag items can specify which items to collect.

[0074] For example, a tag item might be something that specifies an item to be collected, such as a button click, a click of a specific key, a click of a specific item, a touch, or a touch of a specific item.

[0075] Trigger items can set conditions under which tag items are executed.

[0076] For example, a trigger item may be an item that causes data to be collected when an action occurs, such as a button click, a specific key click, a specific item click, a touch, or a touch of a specific item.

[0077] For another example, a trigger item might be one that causes data to be collected when certain data changes.

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

[0079] According to some embodiments of the present disclosure, a command signal may be generated to selectively collect at least one tag item each based on a user interaction input corresponding to a pre-designated graphical object. Here, the user interaction may be an interaction performed between a server (100) and a user of the server (100).

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

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

[0082] The pre-specified graphic objects may include a first graphic object representing a collection command corresponding to a first tag item, a 1-1 graphic object representing an execution command for a trigger condition associated with the first tag item, and a 1-2 graphic object representing a collection command for a variable associated with the first tag item. The 1-1 graphic object and the 1-2 graphic object may be sub-objects of the first graphic object.

[0083] Specifically, the command signal may be generated to collect a first tag item in response to a user input for the first graphical object. When generated to collect a first tag item, the command signal may be generated to selectively collect a first trigger item in response to a user interaction for the first-1 graphical object.

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

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

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

[0087] The user terminal (200) can determine a response signal to a command signal based on the presence or absence of an application programming interface (API) corresponding to the command signal (S140).

[0088] Specifically, the user terminal (200) can determine whether a first tag item exists among at least one tag item, from which tags are determined to be collected, based on a command signal. If the first tag item exists, the user terminal (200) can determine whether to collect a first trigger item included in the first tag item based on the command signal. In addition, if the first tag item exists, the user terminal (200) can determine whether to collect a first variable item included in the first tag item based on the command signal.

[0089] For example, if a first tag item exists based on a command signal, the user terminal (200) may collect items related to the first tag item. The user terminal (200) may collect items such as a button click, 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, if the first tag item, which is determined to be collected among at least one tag item based on the command signal, does not exist, the user terminal (200) may not collect items related to the first tag item.

[0090] When the user terminal (200) decides to collect the first trigger item, it can collect data according to the occurrence of an action such as a button click, 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 trigger item.

[0091] 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.

[0092] The user terminal (200) can generate a command by parsing a command signal. Parsing may be an operation of generating a command by decomposing the components of a sentence and determining the hierarchical relationship of the decomposed components. The user terminal (200) may interpret the script content of the command signal and convert it into a command for execution. The user terminal (200) may execute the generated command to determine whether an API corresponding to the command signal exists in the library. Here, the API may be an interface defined in a second programming language corresponding to the operating system of the user terminal (200).

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

[0094] For another example, the user terminal (200) may be an iOS-based terminal. In this case, the API may be an interface defined in a programming language corresponding to the iOS operating system.

[0095] According to some embodiments of the present disclosure, the user terminal (200) can determine a response signal based on whether an API corresponding to the command signal exists within the library.

[0096] 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.

[0097] For another example, if an API corresponding to a command signal does not exist within the library, the user terminal (200) may transmit an error signal as a response signal. An example of a method for the user terminal (200) to transmit a response signal is described below with reference to FIG. 3.

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

[0099] For example, a command signal might contain scripts related to deviceBrand, displaySize, and view("Button").text.

[0100] The API corresponding to the script related to deviceBrand may be an API that verifies the brand of the user terminal (200). The user terminal (200) may return a brand such as "google," "samsung," or "apple" through the API.

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

[0102] The API corresponding to a script related to view("Button") can be view(argument). The API can retrieve the UI corresponding to the given argument and return an instance of that UI (a value that uniquely identifies the UI in the application).

[0103] The API corresponding to the script associated with .text may be instance,text. The API can check and return the text displayed to the user in the corresponding UI instance.

[0104] The user terminal (200) can transmit the values ​​returned through the APIs as response signals to an address defined in the library. In one embodiment, the user terminal (200) can convert the returned values ​​into human-readable text and transmit it to the server (100).

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

[0106] Meanwhile, according to some embodiments of the present disclosure, the user terminal (200) can determine a response signal based on whether an API corresponding to the command signal exists within the library. Hereinafter, an example of a method for the user terminal (200) according to the present disclosure to transmit a response signal will be described with reference to FIG. 3.

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

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

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

[0110] For example, a command signal might contain scripts related to deviceBrand, displaySize, and view("Button").text.

[0111] The API corresponding to the script related to deviceBrand may be an API for verifying the brand of the user terminal (200). If an API corresponding to the script related to deviceBrand exists, the user terminal (200) may return a brand such as "google," "samsung," or "apple" as an output value. Furthermore, the user terminal (200) may transmit the returned output value as a response signal to an address defined in the library.

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

[0113] For example, an API corresponding to a script related to displaySize may be an API for checking the screen resolution of the user terminal (200). If there is no API corresponding to the script related to displaySize, the user terminal (200) may transmit an error signal as a response signal to an address defined in the library.

[0114] According to the above-described configuration, the user terminal (200) can receive a command signal from the server (100). The command signal may only include a script for adding or modifying items for data collection. Accordingly, the command signal can only read data from variables in the code of the application installed on the user terminal (200) without generating or modifying data. Accordingly, even if the user terminal (200) receives a command signal from the server (100), no problems may occur in the installed application.

[0115] Below, an example of a method in which a server (100) receives a response signal from a user terminal (200) is described.

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

[0117] Referring to FIG. 4, the server (100) can receive a report signal for command reception readiness from the user terminal (200) (S210).

[0118] Specifically, the user terminal (200) can access a pre-designated library in response to the execution of the target application. Upon accessing the pre-designated library, the user terminal (200) can transmit a report signal indicating readiness to receive a command to an address defined in the library. Accordingly, the server (100) can receive the report signal.

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

[0120] For example, the server (100) can transmit a command signal written in a script language or including a script to the user terminal (200).

[0121] According to one embodiment, the server (100) may determine whether a first tag item exists among at least one tag item, which is determined to be collected, based on a user interaction input. If the first tag item exists, the server (100) may determine whether to collect a first trigger item included in the first tag item based on the user interaction input. Furthermore, if the first tag item exists, the server (100) may determine whether to collect a first variable item included in the first tag item based on the user interaction input. The server (100) may generate a command signal based on the determination result.

[0122] 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 another example, the server (100) may generate a command signal to collect the first tag item and the first trigger item. As another example, the server (100) may generate a command signal to collect the first tag item and the first variable item. As another example, the server (100) may generate a command signal not to collect the first tag item. In this case, the command signal may be generated so that the first trigger item and the first variable item are also not collected.

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

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

[0125] For another example, if an API corresponding to the command signal does not exist in the library of the user terminal (200), the server (100) may receive an error signal for the command signal as a response signal.

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

[0127] Referring to Figure 5, a developer can plan an app. "App" may be an abbreviation for "application." The developer can develop a program based on the plan. The developer can add code to the program as an SDK to start a remote scripting system when the app starts. The developer can build the app. Once the app is built, all of its functions can be tested. Based on the test results, the developer can fix any bugs found. The developer can then distribute the app.

[0128] As the app is distributed, the user terminal (200) can install or patch the app through the market provided by the operating system. The user terminal (200) can use the app based on user input. The developer can review the app by receiving data based on app usage.

[0129] Developers can decide what data to add. Previously, if they decided to add data to be collected from a user terminal (200), they had to go back to the program development (or program modification) stage and rebuild the program. This required them to go through the app build, testing, bug fixing, and deployment processes again. In contrast, according to the method supporting data collection according to the present disclosure, developers can conveniently add data to be collected by simply adding the script code to be collected to the remote settings.

[0130] Specifically, once the developer has determined the additional collection content, they can add the script code to be collected to the remote settings. The developer can test simple collection. Since there are no changes to the application itself and only the values ​​of the remote settings script are obtained, the simple collection test can be performed quickly. The developer can apply the script code to 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. Accordingly, the user terminal (200) can collect the data added to the remote settings. The user terminal (200) can then transmit the collected data to the developer. The developer can review the added data collection content.

[0131] FIG. 6 is a diagram illustrating an example of at least one tag item according to some embodiments of the present disclosure. FIG. 6 may be a diagram illustrating an example of at least one tag item, but does not represent a user interface provided by the server (100).

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

[0133] 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 a 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 the user interaction input.

[0134] 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 a 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 the user interaction input.

[0135] According to some embodiments of the present disclosure, the first tag item (410) may be a basic tag item using predefined tag items. The second tag item (420) may be a user-created tag item. In other words, at least one tag item may include at least one of a basic tag item and a user-created tag item.

[0136] The basic tag item may be an item with a built-in remote script pre-written by the developer of the server (100), etc. The user-written tag item may be an item with a remote script written by a user who purchased a program for executing the method of supporting the aforementioned data collection.

[0137] Similar types of applications often have similar data collection requirements for the companies developing them. Therefore, the server (100) can provide default tag items based on the typical requirements of each developer. However, while these requirements may be similar, they may not be identical across all developments. Therefore, users can create custom tag items tailored to their needs.

[0138] The description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present disclosure. Various modifications to these embodiments will be readily 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 to the embodiments disclosed herein, but is to be construed in the broadest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for supporting data collection for a user terminal including at least one processor, A step of accessing a pre-specified library in response to the execution of a target application; A step of transmitting a report signal for readiness to receive a command to an address defined in the above library; A step of receiving a command signal defined in a first programming language; A step of determining a response signal to the command signal based on the presence or absence of an API (application programming interface) corresponding to the command signal; and A step of transmitting the response signal to an address defined in the above library; including, How to support data collection.

2. In paragraph 1, The API corresponding to the above command signal is: Defined as a second programming language corresponding to the operating system of the user terminal, How to support data collection.

3. In paragraph 1, The step of determining the above response signal is: If an API corresponding to the command signal exists in the library, a step of transmitting an output value defined in the API as the response signal to an address defined in the library; or If an API corresponding to the command signal does not exist in the library, a step of transmitting an error signal for the command signal as the response signal to an address defined in the library; including, How to support data collection.

4. In paragraph 1, The step of determining a response signal to the command signal based on the presence or absence of an application programming interface (API) corresponding to the command signal is as follows: A step of generating a command by parsing the above command signal; and A step of executing a generated command to determine whether an API corresponding to the command signal exists within the library; including, How to support data collection.

5. In paragraph 1, The above command signal is, Contains at least one tag entry specifying the tags to be collected, Each of the above at least one tag item, Including a trigger item that sets the condition for executing the above tag item and a variable item that specifies the data to be collected. How to support data collection.

6. In paragraph 5, The above command signal is, wherein each of said at least one tag item is generated to be selectively collected based on a user interaction input corresponding to a pre-specified graphic object; The above-mentioned pre-specified graphic object includes a first graphic object representing a collection command corresponding to a first tag item, a 1-1 graphic object representing an execution command for a trigger condition associated with the first tag item, and a 1-2 graphic object representing a collection command for a variable associated with the first tag item. How to support data collection.

7. In paragraph 6, The step of determining a response signal to the command signal based on the presence or absence of an application programming interface (API) corresponding to the command signal is as follows: A step of determining whether there is a first tag item among the at least one tag item determined to collect a tag based on the command signal; If the first tag item exists, a step of determining whether to collect the 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 each of the first variable items included in the first tag item based on the command signal; including, How to support data collection.

8. In paragraph 5, At least one tag item above, Contains at least one of a basic tag item and a user-created tag item that uses a predefined tag item. How to support data collection.

9. A method for supporting data collection for a server including at least one processor, A step of receiving a report signal for readiness to receive a command from a user terminal; a step of transmitting a command signal defined in a first programming language in response to the above report signal; and A step of receiving a response signal to the command signal from the user terminal; including, How to support data collection.

10. In paragraph 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 library of the user terminal, a step of receiving an output value defined in the API as the response signal; or A step of receiving an error signal in response to the command signal when an API corresponding to the command signal does not exist in the library; including, How to support data collection.

11. In paragraph 10, The API corresponding to the above command signal is: Defined as a second programming language corresponding to the operating system of the user terminal, How to support data collection.

12. In paragraph 10, The above command signal is, 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. How to support data collection.

13. In paragraph 9, The above command signal is, Contains at least one tag entry specifying the tags to be collected, Each of the above at least one tag item, Including a trigger item that sets the condition for executing the above tag item and a variable item that specifies the data to be collected. How to support data collection.

14. In paragraph 13, The above command signal is, wherein each of said at least one tag item is generated to be selectively collected based on a user interaction input corresponding to a pre-specified graphic object; The above-mentioned pre-specified graphic object includes a first graphic object representing a collection command corresponding to a first tag item, a 1-1 graphic object representing an execution command for a trigger condition associated with the first tag item, and a 1-2 graphic object representing a collection command for a variable associated with the first tag. How to support data collection.

15. In paragraph 14, The step of transmitting a command signal defined in a first programming language in response to the above report signal is: A step of determining whether a first tag item exists among the at least one tag item for which a tag is determined to be collected based on the user interaction input; If the first tag item exists, a step of determining whether to collect the 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 each of the first variable items included in the first tag item based on the user interaction input; including, How to support data collection.

16. In paragraph 15, At least one tag item above, Contains at least one of a basic tag item and a user-created tag item that uses a predefined tag item. How to support data collection.

Images