Data acquisition method, device, computer equipment and storage medium

Abstract

The embodiments of the present application disclose a data acquisition method, device, computer equipment and storage medium, which belong to the field of computer technology. The method includes: obtaining a trigger event for a cell in any list page through a proxy object; forwarding the trigger event to a target object through the proxy object, the target object includes a processing method code for processing any trigger event of a cell, and a buried point code is set in the processing method code; running the target processing method code corresponding to the trigger event to process the trigger event; obtaining buried point data through the buried point code in the target processing method code. This solution only needs to add buried point code in the target object to record events occurring in any list page, which reduces the number of buried point codes, reduces labor costs, and improves R&D efficiency.

Description

Technical Field

[0001] The embodiments of the present application relate to the field of computer technology, and in particular to a data acquisition method, apparatus, computer equipment, and storage medium. Background Art

[0002] Currently, applications usually display data to users through list pages. Cells are the basic components of list pages. List pages can display pictures, buttons, text, videos, and other data through cells. Users can perform various operations on these cells to process the data displayed by the cells. Among them, user operations will generate various user behavior data. In order to facilitate the analysis of user behavior data, it is usually adopted to write tracking code in the code of display, sliding, clicking and other events in the source code of the list page to obtain user behavior data.

[0003] In the process of implementing the present application, the inventor discovered that the codes of cells in some different list pages are the same, which would cause technicians to write the same embedding code in the source code of these different list pages, thereby resulting in a waste of human resources and reduced R&D efficiency. Summary of the invention

[0004] The embodiments of the present application provide a data acquisition method, device, computer equipment and storage medium, which reduce labor costs and improve research and development efficiency. The technical solution is as follows:

[0005] In one aspect, a data acquisition method is provided, the method comprising:

[0006] Get the trigger event of the cell in any list page through the proxy object;

[0007] Forwarding the trigger event to a target object through the proxy object, wherein the target object includes a processing method code for processing any trigger event of a cell, and a embedding code is set in the processing method code;

[0008] Run the target processing method code corresponding to the trigger event to process the trigger event;

[0009] The embedded point data is obtained through the embedded point code in the target processing method code.

[0010] In another aspect, a data acquisition device is provided, the device comprising:

[0011] A first acquisition module is used to acquire a triggering event for a cell in any list page through a proxy object;

[0012] A forwarding module, used for forwarding the trigger event to a target object through the proxy object, wherein the target object includes a processing method code for processing any trigger event of a cell, wherein the processing method code is provided with a buried point code;

[0013] An operation module, used for executing a target processing method code corresponding to the trigger event to process the trigger event;

[0014] The second acquisition module is used to acquire the embedded point data through the embedded point code in the target processing method code.

[0015] On the other hand, a computer device is provided, comprising a processor and a memory, wherein the memory stores at least one program code, and the at least one program code is loaded and executed by the processor to implement the operations performed in the data acquisition method described in the above aspects.

[0016] On the other hand, a computer-readable storage medium is provided, in which at least one program code is stored. The at least one program code is loaded and executed by a processor to implement the operations performed in the data acquisition method described in the above aspects.

[0017] On the other hand, a computer program product is provided, wherein at least one program code is stored in the computer program product, and the at least one program code is loaded and executed by a processor to implement the operations performed in the data acquisition method of the above embodiment.

[0018] The data acquisition method, device, computer equipment and storage medium provided in the embodiments of the present application provide a target object, which includes a processing method code for processing any cell trigger event of a cell. Therefore, the target object can process the cell trigger event of any list page. Therefore, it is only necessary to add the embedding code to the target object to record the events occurring in any list page, which reduces the number of embedding codes, reduces labor costs, and improves R&D efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0020] Figure 1 It is a structural diagram of an implementation environment provided by an embodiment of the present application;

[0021] Figure 2 is a flow chart of a data acquisition method provided in an embodiment of the present application;

[0022] Figure 3 is a flow chart of another data acquisition method provided in an embodiment of the present application;

[0023] Figure 4 It is a schematic diagram of an agent class provided in an embodiment of the present application;

[0024] Figure 5 It is a processing flow chart of a proxy object provided in an embodiment of the present application;

[0025] Figure 6 is a flow chart of a data acquisition method provided in an embodiment of the present application;

[0026] Figure 7 is a flow chart of a data acquisition method provided in an embodiment of the present application;

[0027] Figure 8 is a flow chart of a data acquisition method provided in an embodiment of the present application;

[0028] Fig. 9 is a structural schematic diagram of a data acquisition device provided in an embodiment of the present application;

[0029] Fig.10 A schematic diagram of the structure of another data acquisition device provided in an embodiment of the present application;

[0030] Fig.11 is a schematic diagram of the structure of a terminal provided in an embodiment of the present application;

[0031] Fig.12 It is a structural diagram of a server provided in an embodiment of the present application. DETAILED DESCRIPTION

[0032] In order to make the objectives, technical solutions and advantages of the embodiments of the present application clearer, the implementation methods of the present application will be further described in detail below in conjunction with the accompanying drawings.

[0033] It is understood that the terms "first", "second", "third", "fourth", "fifth", "sixth", etc. used in this application can be used in this article to describe various concepts, but unless otherwise specified, these concepts are not limited by these terms. These terms are only used to distinguish one concept from another concept. For example, without departing from the scope of this application, the first processing result can be called the second processing result, and the second processing result can be called the first processing result.

[0034] The terms "each", "plurality", "at least one", "any" and the like used in this application include one, two or more than two, and "plurality" includes two or more than two. "each" refers to each of the corresponding "plurality" and "any" refers to any one of the "plurality". For example, "plurality" includes three objects, and "each" refers to each of the three objects, and "any" refers to any one of the three objects, which may be the first, the second or the third.

[0035] It can be understood that in the specific implementation of the present application, if the tracking data obtained by the tracking code involves user information, user behavior data and other user-related data, when the above embodiments of the present application are applied to specific products or technologies, it is necessary to obtain user permission or consent, and the collection, use and processing of relevant data need to comply with relevant laws, regulations and standards of relevant countries and regions.

[0036] The data acquisition method provided in the embodiment of the present application is executed by a computer device. In one possible implementation, the computer device is a terminal, such as a mobile phone, a tablet computer, a computer, etc. In another possible implementation, the computer device includes a terminal and a server.

[0037] Figure 1 is a schematic diagram of an implementation environment provided by an embodiment of the present application. Figure 1 , the implementation environment includes a terminal 101 and a server 102. The terminal 101 and the server 102 are connected via a wireless or wired network.

[0038] The target application provided by the server 102 is installed on the terminal 101, and the terminal 101 can realize functions such as data transmission and message interaction through the target application. Optionally, the target application is a target application in the operating system of the terminal 101, or a target application provided by a third party. For example, the target application is a multimedia processing application, and the multimedia processing application has the function of playing multimedia data, such as the function of playing video, the function of playing audio, etc. Of course, the multimedia processing application can also have other functions, such as sharing function, commenting function, etc. Optionally, the server 102 is the background server of the target application or a cloud server that provides services such as cloud computing and cloud storage.

[0039] Optionally, the terminal 101 obtains the burying point data through the burying point code, and sends the burying point data to the server 102, and the server 102 receives and stores the burying point data.

[0040] The data acquisition method provided in the embodiment of the present application can be applied to the operation scenario of any application to obtain the tracking data during the operation of the application. The embodiment of the present application does not limit the application scenario.

[0041] Figure 2 1 is a flowchart of a text data display method provided in an embodiment of the present application. This embodiment of the present application takes the execution subject as a terminal as an example for exemplary description. Figure 2 , the method comprising:

[0042] 201. The terminal obtains a trigger event for a cell in any list page through a proxy object.

[0043] Cells are the basic components that make up a list page. List pages can display pictures, buttons, text videos, videos and other data through cells. The codes of cells in some different list pages are the same. For example, in some short video applications, when users watch different list pages by sliding up and down, the codes of cells in these different list pages are the same, but the source data of these cells are different, so the contents displayed in these cells are different. The cells in the above step 201 can be the same cells as the cells in other list pages. Of course, in the case where the cells in different list pages are different, the solution provided by the embodiment of the present application can also be applied. Therefore, the cells in the above step 201 can also be cells different from the cells in other list pages. The same cells here refer to the same codes of the cells, and the different cells here refer to the different codes of the cells.

[0044] A proxy object is an object with a forwarding function, which can forward the acquired trigger event to other objects. A list page refers to a page developed in the form of a list. Most of the pages currently provided in applications are list pages. A trigger event refers to any event triggered on any cell in a list page. The event can be a click event, a display event, a sliding event, etc. The embodiments of this application do not limit the trigger event.

[0045] 202. The terminal forwards the trigger event to the target object through the proxy object. The target object includes a processing method code for processing any trigger event of the cell. The processing method code is provided with a embedding code.

[0046] Since the target object includes a processing method code for processing any triggering event of a cell, the target object can process any triggering event of a cell. Thus, the proxy object can forward the triggering event to the target object, and the target object processes the triggering event.

[0047] For example, the target object includes a processing method code for processing a sliding event, a processing method code for processing a display event, a processing method code for processing a click event, and the like.

[0048] In an embodiment of the present application, the embedding code is added to the processing method code included in the target object. During the process of the processing method code processing the triggering event, the embedding code in the processing method code will also be executed to obtain the embedding data.

[0049] 203. The terminal runs the target processing method code corresponding to the trigger event to process the trigger event.

[0050] Different types of trigger events require different processing method codes to process. Among them, the target processing method code corresponding to the trigger event is the processing method code used to process the trigger event.

[0051] For example, if the trigger event is a click event, the processing method code corresponding to the click event is run to process the cell event, that is, the processing method code for processing the click event is run to process the trigger event.

[0052] 204. The terminal obtains the embedded point data through the embedded point code in the target processing method code.

[0053] In an embodiment of the present application, a point-embedding code is set in each processing method code in the target object. When any processing method code is executed, the point-embedding code in the processing method code will also be executed, and the point-embedding data will be obtained accordingly.

[0054] Among them, the burying point code can be set manually by a technician, or it can be set in the processing method code through other programs. The embodiment of the present application does not limit the setting method of the burying point code.

[0055] The burying point data is the data collected by the burying point code. After the burying point code collects the data, it can also report the data to the server. The burying point data can be user behavior data or other data. The embodiments of the present application do not limit the burying point data.

[0056] For example, the trigger event may be a click event, and the embedding code may obtain data such as the click object and number of clicks of the click event, and report the data.

[0057] The data acquisition method provided in the embodiment of the present application provides a target object, which includes a processing method code for processing any trigger event of a cell. Therefore, the target object can process the trigger event of any list page. Therefore, it is only necessary to add a point-embedding code to the target object to record the events occurring in any list page, thereby reducing the number of point-embedding codes, reducing labor costs, and improving R&D efficiency.

[0058] In a possible implementation, the trigger event carries a cell identifier of a triggered cell, and the target object is a cell object;

[0059] The forwarding the trigger event to the target object through the proxy object includes:

[0060] The trigger event is forwarded to the cell object corresponding to the cell identifier through the proxy object based on the cell identifier.

[0061] In a possible implementation, forwarding the trigger event to the cell object corresponding to the cell identifier based on the cell identifier by the proxy object includes:

[0062] Determine, by the proxy object, a cell object corresponding to the cell identifier based on the cell identifier in the trigger event;

[0063] Obtaining the protocol followed by the cell object, wherein the protocol is used to define a processing method code for a triggering event;

[0064] When the protocol followed by the cell object is the target protocol, the trigger event is forwarded to the cell object corresponding to the cell identifier. The processing method code defined by the target protocol is the same as the processing method code in the controller of the list page. The controller is used to handle any trigger event of the list page.

[0065] In a possible implementation, determining, by the proxy object, the cell object corresponding to the cell identifier based on the cell identifier in the trigger event includes:

[0066] Forwarding the trigger event to the event processing object through the proxy object;

[0067] Determine, by the event processing object, a cell object corresponding to the cell identifier based on the cell identifier in the triggering event;

[0068] When the protocol followed by the cell object is the target protocol, forwarding the trigger event to the cell object corresponding to the cell identifier includes:

[0069] In a case where the protocol followed by the cell object is the target protocol, the trigger event is forwarded to the cell object corresponding to the cell identifier through the event processing object.

[0070] In a possible implementation, the target object is an event processing object, and the event processing object is used to process a triggering event; and forwarding the triggering event to the target object through the proxy object includes:

[0071] The trigger event is forwarded to the event processing object through the proxy object, so that the target processing method code in the event processing object processes the trigger event.

[0072] In a possible implementation, forwarding the trigger event to the event processing object through the proxy object includes:

[0073] Obtaining the protocol followed by the event processing object, wherein the protocol is used to define the processing method code for the triggering event;

[0074] In the case that the protocol followed by the event processing object is the target protocol, the trigger event is forwarded to the event processing object through the proxy object.

[0075] In a possible implementation, forwarding the trigger event to the event processing object through the proxy object includes:

[0076] Obtaining a responder list through the proxy object, wherein the responder list is used to record responders that process the triggering event;

[0077] In a case where the responder list includes the event processing object, the trigger event is forwarded to the event processing object through the proxy object.

[0078] In a possible implementation, before obtaining the responder list through the proxy object, the method further includes:

[0079] Binding the proxy object and the event processing object to the list class;

[0080] When any list page is loaded, the controller of the list page and the event processing object bound to the list class are added to the responder list through the proxy object bound to the list class.

[0081] In another possible implementation, the trigger event carries a cell identifier of a triggered cell, and the target object is an event processing object;

[0082] The running of the target processing method code corresponding to the triggering event to process the triggering event includes:

[0083] Based on the cell identifier, obtaining target data in the cell corresponding to the cell identifier from the cell class;

[0084] The target processing method code corresponding to the triggering event is run to process the target data.

[0085] In another possible implementation, the target object is a responder object, the responder object is an object created based on a responder class, and the responder class is a class for processing buried points;

[0086] The forwarding the trigger event to the target object through the proxy object includes:

[0087] The trigger event is forwarded to the responder object through the proxy object.

[0088] In a possible implementation, after obtaining a trigger event for any list page through the proxy object, the method further includes:

[0089] Forwarding the trigger event to the controller of the list page through the proxy object;

[0090] The trigger event is processed by the controller to update the list page.

[0091] All the above optional technical solutions can be arbitrarily combined to form optional embodiments of the present application, which will not be described one by one here.

[0092] It should be noted that in the embodiments of the present application, the target object is an object that can handle any type of triggering event, and the target object includes a processing method code for handling any type of triggering event. In one possible implementation, the target object is a cell object, which is an object created based on a cell class. In another possible implementation, the target object is an event processing object, which is an object created based on an event processing class EvenHandler. In another possible implementation, the target object is a responder object, which is an object created based on a responder class, which is a class that specializes in processing buried points. The following is through Figure 3 In the illustrated embodiment, a target object is a cell object as an example to exemplarily illustrate the data acquisition method.

[0093] Figure 3 is a flow chart of a data acquisition method provided in an embodiment of the present application. Figure 3 The embodiment of the present application takes the execution subject as a terminal as an example for illustrative description, and the method includes:

[0094] 301. The terminal obtains a trigger event for a cell in any list page through a proxy object.

[0095] The proxy object is an object with forwarding function. Optionally, the proxy object will hold a responder list, which records at least one object. For example, the controller of the list page, the cell object corresponding to the cell in the list page, the event processing object, etc. After the proxy object obtains any message, it will forward the message to the object recorded in the responder list, and the object recorded in the responder list will forward or process the message. Therefore, the object recorded in the responder list can be regarded as the responder of the message received by the proxy object.

[0096] By adding the target object to the responder list, when the proxy object obtains a trigger event for any list page, the trigger event can be forwarded to the target object, making the target object a responder of the trigger event in the list page.

[0097] Optionally, the proxy object can also add or delete responders in the responder list. Optionally, the proxy object adds the object ID of a certain object in the responder list, so that the object becomes the responder of the trigger event of the list page. After the proxy object receives any message, based on the object ID in the responder list, the message is forwarded to the object corresponding to the object ID.

[0098] The proxy object is an object created based on the proxy class. Optionally, the proxy object is an object created based on NSProxy (a proxy class); Figure 4 As shown, the embodiment of the present application adds a proxy class (ForwardProxy), which inherits from NSProxy (a proxy class) and has all the properties of NSProxy, and of course can also have other properties. The proxy class ForwardProxy is a newly added proxy class in the program of the present application.

[0099] The list page can be regarded as a scrollable page view in the application. The cell is the basic component of the list page, and data such as pictures, buttons, and text views can be displayed through the cell.

[0100] A list class is set in the terminal. When the list page is loaded, the terminal will create a list object based on the list class. In order for the proxy object to receive the trigger event in the list page, a binding relationship between the proxy object and the list object can be established. Since different list pages correspond to different list objects, in order for the proxy object to receive the trigger event in any list page, each list object needs to be bound to the proxy object. Optionally, each time the terminal creates a list object, it binds the created list object to the proxy object; optionally, the terminal binds the proxy object to the list class, so that each list object created based on the list class will inherit the binding relationship, thereby realizing that each list object created based on the list class is bound to the proxy object.

[0101] For example, when a terminal displays any list page, a user performs a trigger operation on a cell in the list page, and the proxy object bound to the list object obtains a trigger event corresponding to the trigger operation.

[0102] 302. The terminal forwards the trigger event to the cell object through the proxy object. The cell object includes a processing method code for processing any trigger event. The processing method code is provided with a embedding code.

[0103] The terminal is also provided with a cell class, which is a subclass of the list class, and the cell object is an object created based on the cell class. Among them, the cell class includes a processing method code for processing any trigger event, so the cell objects created based on the cell all include a processing method code for processing any trigger event. In addition, the embodiment of the present application sets a buried point code in the processing method code of the cell class, so the processing method code of the cell objects created based on the cell is also set with a buried point code.

[0104] The list page can include multiple cells, and the trigger event obtained by the proxy object can be a trigger event for any cell. The cell objects created based on the cell class correspond one-to-one to the cells in the list page. For example, the list page includes cell 1, cell 2, and cell 3, and three cell objects are created based on the cell class, namely cell object 1, cell object 2, and cell object 3. Therefore, the proxy object needs to forward the received trigger event to the corresponding cell object for processing.

[0105] In the embodiment of the present application, a cell is a front-end representation of a cell object, and a cell object is the source code of a cell. For example, when a terminal accesses a list page, the terminal creates at least one cell object for the list page based on the cell class, and displays at least one corresponding cell in the list page based on the at least one created cell object, and the cell is used to present corresponding data (buttons, pictures, text, videos, etc.). Subsequently, if the user performs a trigger operation on a cell in the list page, the proxy object can forward the trigger event generated by the trigger operation to the cell object of the cell for processing.

[0106] It should be noted that, in a possible implementation, the list page includes multiple different types of cells. For example, a cell that displays a "comment" button, a cell that displays a "like" button, and a cell that displays a picture. Accordingly, the terminal includes at least three cell classes: cell class 1, cell class 2, and cell class 3. Among them, cell class 1 is used to create a cell object that displays a "comment" button, cell class 2 is used to create a cell object that displays a "like" button, and cell class 3 is used to create a cell object that displays a picture. When the terminal accesses the list page, the terminal creates a first cell object based on cell class 1, and based on the created first cell object, displays a cell containing a "comment" button in the list page; the terminal creates a second cell object based on cell class 2, and based on the created second cell object, displays a cell containing a "like" option in the list page; the terminal creates a third cell object based on cell class 3, and based on the created third cell object, displays a cell containing a picture in the list page.

[0107] That is to say, each cell class is used to create a cell object corresponding to a type of cell. For example, list page 1, list page 2, list page 3, and list page 4 all include cells that display the "Like" option, so the cells used to display the "Like" option in list page 1, list page 2, list page 3, and list page 4 are all displayed by creating corresponding cell objects based on the same cell class. For another example, list page 1, list page 2, list page 3, and list page 4 all include cells with a length of x, a width of y, and a rectangular shape; then, the cells with a length of x, a width of y, and a rectangular shape in list page 1, list page 2, list page 3, and list page 4 are all displayed by creating corresponding cell objects based on the same cell class.

[0108] In one implementation, although the source code corresponding to the cells for displaying the "Like" option in the four list pages is the same, the terminal still creates a cell object for each cell for displaying the "Like" option in the list page. Moreover, although the source code of these cell objects is the same, the data sources of these cell objects are different, and the displayed contents may also be different.

[0109] For example, list page 1 is the viewing page of short video A, and cell 1 is used to display the "Like" icon and the total number of likes for short video A; list page 2 is the viewing page of short video B, and cell 2 is used to display the "Like" icon and the total number of likes for short video B; among them, the codes in the cell object corresponding to cell 1 and the cell object corresponding to cell 2 are the same, but the data sources of the two cell objects are different, and the total number of likes displayed is different.

[0110] In one possible implementation, the trigger event carries the cell identifier of the triggered cell; the terminal forwards the trigger event to the cell object through the proxy object, including: the terminal forwards the trigger event to the cell object corresponding to the cell identifier through the proxy object based on the cell identifier.

[0111] Among them, the cell identifier can be any identifier that can identify a unique cell, such as a cell name, a cell number, etc., and the embodiment of the present application does not limit the cell identifier.

[0112] For example, the terminal forwards the trigger event to cell object 1 based on cell identifier 1 through the proxy object.

[0113] It should be noted that, in a possible implementation, each list page corresponds to a controller, through which various events in the list page are processed and the display content of the list page is updated. The cell object in the embodiment of the present application only processes the trigger event so that the buried point code can obtain the buried point data, but it will not affect the list page. Therefore, in order to ensure that the buried point data obtained by the buried point code is accurate, the processing result of the cell object needs to be consistent with the processing result of the controller.

[0114] Optionally, the embodiment of the present application defines a method for processing a trigger event through a protocol, so whether the processing method code in the cell object is the same as the processing method code in the controller can be determined through the protocol followed by the cell object. If the processing method code in the cell object is the same as the processing method code in the controller, then the processing result of the cell object is also the same as the processing result in the controller, and the buried point data obtained by setting the buried point code in the controller and setting the buried point code in the cell object are also the same, ensuring that the buried point data obtained by the buried point code is accurate.

[0115] In one possible implementation, the terminal forwards the trigger event to the cell object corresponding to the cell identifier through the proxy object based on the cell identifier, including: the terminal determines the cell object corresponding to the cell identifier through the proxy object based on the cell identifier in the trigger event; the terminal obtains the protocol followed by the cell object, and the protocol is used to define the processing method code for the trigger event; when the protocol followed by the cell object is the target protocol, the cell trigger event is forwarded to the cell object corresponding to the cell identifier, the processing method code defined by the target protocol is the same as the processing method code in the controller of the list page, and the controller is used to process any trigger event of the list page.

[0116] Optionally, the cell object includes a protocol table, which includes the protocol followed by the cell object, so the proxy object can determine the protocol followed by the cell object by querying the protocol table. It should be noted that the embodiment of the present application is only an exemplary description of obtaining the protocol followed by the cell object, and does not limit it.

[0117] It should be noted that in the embodiments of the present application, the proxy object can directly forward the trigger event to the cell object, and the proxy object can also forward the trigger event to the cell object through other objects, and the embodiments of the present application do not limit this.

[0118] In one possible implementation, the terminal forwards the trigger event to the cell object through the proxy object, including: the terminal forwards the trigger event to the event processing object through the proxy object, determines the cell object corresponding to the cell identifier based on the cell identifier in the trigger event through the event processing object; and forwards the trigger event to the cell object through the event processing object.

[0119] Optionally, the event processing object can directly forward the trigger event to the cell object; optionally, the event processing object needs to first determine the protocol followed by the cell object, and only forward the trigger event to the cell object when the protocol followed by the cell object meets the requirements. For example, the terminal forwards the trigger event to the cell object through the event processing object, including: the terminal forwards the trigger event to the event processing object through the proxy object; the terminal determines the cell object corresponding to the cell identifier based on the cell identifier in the trigger event through the event processing object; obtains the protocol followed by the cell object through the event processing object, and the protocol is used to define the processing method code for the trigger event; when the protocol followed by the cell object is the target protocol, forwards the trigger event to the cell object corresponding to the cell identifier through the event processing object.

[0120] It should be noted that the cell object in the embodiment of the present application follows the target protocol (CellProtocol) by making the cell class follow the target protocol. Since the cell object is created based on the cell class, the cell object inherits the properties of the cell class. Thus, if the cell class follows the target protocol, then each cell object created based on the cell class follows the target protocol.

[0121] In a possible implementation, the proxy object holds a responder list, and the proxy object forwards the trigger event to the object recorded in the responder list. The proxy object holding the responder list may mean that the proxy object can obtain the responder list; the proxy object may be bound to the responder list; or the proxy object may include the responder list, etc. The embodiment of the present application does not limit the relationship between the proxy object and the responder list.

[0122] Among them, some list pages have multiple cells, each cell corresponds to a cell object, and adding the cell object to the responder list to forward the trigger event to the corresponding cell object will generate greater operating pressure. Therefore, the embodiment of the present application provides another method, adding the event processing object to the responder list, determining the cell object through the event processing object, and forwarding the trigger event to the corresponding cell object.

[0123] In one possible implementation, the terminal forwards the trigger event to the event processing object through the proxy object, including: obtaining a responder list through the proxy object, the responder list being used to record responders that process the trigger event; and when the responder list includes the event processing object, forwarding the trigger event to the event processing object through the proxy object.

[0124] Optionally, the responders recorded in the responder list may be added by a proxy object, which has the function of adding or deleting responders in the responder list. Optionally, before the terminal obtains the responder list through the proxy object, the method further includes: the terminal binds the proxy object and the event processing object to the list class; when any list page is loaded, the controller of the list page and the event processing object bound to the list class are added to the responder list through the proxy object bound to the list class.

[0125] For example, the technician adds a proxy class ForwardProxy and an event handling class EvenHandler to the program, binds the list class with the proxy class ForwardProxy and the event handling class EvenHandler through methods such as set, and adds a method for setting the data source to the list class. When the program is running, the list class dynamically binds a ForwardProxy proxy object and an EvenHandler event handling object. Figure 5As shown, when the list page is loaded, the controller of the list page is added to the responder list through the ForwardProxy proxy object bound to the list object, and the EvenHandler event processing object is added to the message responder list through the ForwardProxy proxy object. The trigger event of the list page is sent to the ForwardProxy proxy object bound to the list object for processing, and the ForwardProxy proxy object forwards the received trigger event to the cell object for processing; or, as Figure 6 As shown, the ForwardProxy proxy object forwards the trigger event to the controller and EvenHandler event processing object of the list page according to the responder list, and the EvenHandler event processing object forwards the trigger event to the corresponding cell object.

[0126] It should be noted that the ForwardProxy proxy object can also forward the trigger event to the responder list, and the responder list forwards the trigger event to the controller of the list page and the EvenHandler event processing object.

[0127] 303. The terminal runs the target processing method code corresponding to the trigger event to process the trigger event and obtain a first processing result.

[0128] The step 303 is the same as the step 203 and will not be described in detail here.

[0129] 304. The terminal obtains the embedded point data through the embedded point code in the target processing method code.

[0130] The step 304 is similar to the step 204 and will not be described in detail here.

[0131] 305. The terminal forwards the trigger event to the controller of the list page through the proxy object.

[0132] It should be noted that, in a possible implementation, the terminal not only runs the target processing method code corresponding to the triggering event to process the triggering event, but also updates the list page based on the processing result of the target processing method code. In this case, the terminal does not need to perform steps 305 and 306.

[0133] In another possible implementation, the terminal manages the list page through a controller, and in this case, the controller is required to process the trigger event and update the list page. Therefore, the terminal also forwards the trigger event to the controller of the list page through a proxy object so that the controller processes the trigger event.

[0134] Optionally, the proxy object holds a responder list, and the proxy object forwards the trigger event to the objects recorded in the responder list. The terminal forwards the trigger event to the controller of the list page through the proxy object, including: the terminal obtains the responder list through the proxy object, and the responder list is used to record the responders who process the trigger event; when the responder list includes the controller, forward the trigger event to the controller through the proxy object.

[0135] 306. The terminal processes the trigger event based on the controller and updates the list page.

[0136] The controller includes a processing method code for processing any trigger event, and the terminal processes the trigger event based on the controller, including: the terminal runs the target processing method code corresponding to the trigger event through the controller to process the trigger event.

[0137] The data acquisition method provided in the embodiment of the present application provides a proxy object and a cell object, wherein the cell object includes a processing method code for processing any trigger event of the cell; any trigger event of any list page is forwarded to the cell object through the proxy object. Since the cell object can process any trigger event of any list page, it is only necessary to add a point-embedding code to the cell object to record events occurring in any list page, thereby reducing the number of point-embedding codes, reducing labor costs, and improving R&D efficiency.

[0138] In addition, in an embodiment of the present application, before forwarding the trigger event to the cell object, the protocol followed by the cell will be queried first, ensuring that the processing result of the cell object is consistent with the processing result of the controller, thereby ensuring that the tracking data obtained by the tracking code is accurate.

[0139] In addition, in an embodiment of the present application, an event handling object is added. By adding an event handling object to the responder list, the event handling object can forward the triggering event to the corresponding cell object. There is no need to add each cell object to the responder list, which simplifies the operation of the program and improves operating efficiency.

[0140] Below through Figure 7 In the embodiment shown, the data acquisition method is exemplified by taking the target object as an event processing object.

[0141] Figure 7 is a flow chart of a data acquisition method provided by this application. Figure 7 The embodiment of the present application takes the execution subject as a terminal as an example for illustrative description, and the method includes:

[0142] 701. The terminal obtains a triggering event for a cell in any list page through a proxy object.

[0143] The step 701 is the same as the step 301 and will not be described in detail here.

[0144] 702. The terminal forwards the trigger event to the event processing object through the proxy object. The event processing object includes a processing method code for processing any trigger event. The processing method code is provided with a embedding code.

[0145] Similar to step 302, the proxy object may directly forward the trigger event to the event processing object, or may first determine the protocol followed by the event processing object, and then forward the trigger event to the event processing object when the protocol followed by the event processing object meets the requirements.

[0146] In one possible implementation, the terminal forwards the trigger event to the event processing object through the proxy object, including: obtaining the protocol followed by the event processing object, where the protocol is used to define the processing method code for the trigger event; and when the protocol followed by the event processing object is the target protocol, forwarding the trigger event to the event processing object through the proxy object.

[0147] Optionally, the proxy object holds a responder list, and the proxy object forwards the trigger event to the responders recorded in the responder list. In one possible implementation, the terminal forwards the trigger event to the event processing object through the proxy object, including: obtaining a responder list through the proxy object, the responder list is used to record the responders who process the trigger event; when the responder list includes the event processing object, forwarding the trigger event to the event processing object through the proxy object.

[0148] Optionally, before obtaining the responder list through the proxy object, the method also includes: binding the proxy object and the event handling object to the list class; when loading any list page, adding the controller of the list page and the event handling object bound to the list class to the responder list through the proxy object bound to the list class.

[0149] It should be noted that the event processing object in step 702 is similar to the event processing object in step 302, and will not be described one by one here. The only difference is that the event processing object in step 702 includes a processing method code for processing any triggering event, and the event processing object in step 702 is used to process the triggering event. The event processing object in step 702 no longer forwards the triggering event to other objects for processing, but processes it by itself.

[0150] 703. The terminal runs the target processing method code corresponding to the trigger event to process the trigger event.

[0151] Step 703 is similar to step 303 and will not be described in detail here.

[0152] It should be noted that Figure 3 In the embodiment shown, the target object is a cell object, so the cell object can directly obtain the cell data (for example, display content, etc.), and the cell object directly runs the target processing method code to process the obtained cell data. Figure 7 In the embodiment shown, the target object is an event processing object, and the event processing object also needs to obtain cell data from the cell object. In a possible implementation, the terminal runs the target processing method code corresponding to the triggering event through the event processing object to process the triggering event, including: the terminal obtains cell data from the cell object corresponding to the cell identifier based on the cell identifier in the triggering event through the event processing object, and runs the target processing method code to process the obtained cell data.

[0153] 704. The terminal obtains the embedded point data through the embedded point code in the target processing method code.

[0154] The step 704 is the same as the step 204 and will not be described in detail here.

[0155] 705. The terminal forwards the trigger event to the controller of the list page through the proxy object.

[0156] The step 705 is the same as the step 305 and will not be described in detail here.

[0157] 706. The terminal processes the trigger event through the controller and updates the list page.

[0158] The step 706 is similar to the step 306 and will not be described in detail here.

[0159] The data acquisition method provided in the embodiment of the present application provides an event processing object, which includes a processing method code for processing any trigger event of a cell. Therefore, the event processing object can process the trigger event of any list page. Therefore, it is only necessary to add the embedding code to the event processing object to record the events occurring in any list page, thereby reducing the number of embedding codes, reducing labor costs, and improving R&D efficiency.

[0160] Below through Figure 8 In the illustrated embodiment, the data acquisition method is exemplified by taking the target object as the responder processing object.

[0161] Figure 8is a flow chart of a data acquisition method provided by this application. Figure 8 The embodiment of the present application takes the execution subject as a terminal as an example for illustrative description, and the method includes:

[0162] 801. The terminal obtains a triggering event for a cell in any list page through a proxy object.

[0163] The step 801 is the same as the step 301 and will not be described in detail here.

[0164] 802. The terminal forwards the trigger event to the responder object through the proxy object. The responder object includes a processing method code for processing any trigger event. The processing method code is provided with a embedding code.

[0165] Similar to step 302, the proxy object may directly forward the trigger event to the responder object, or may first determine the protocol followed by the responder object, and then forward the trigger event to the responder object when the protocol followed by the responder object meets the requirements.

[0166] In one possible implementation, the terminal forwards the trigger event to the responder object through the proxy object, including: obtaining the protocol followed by the responder object, where the protocol is used to define the processing method code for the trigger event; and when the protocol followed by the responder object is the target protocol, forwarding the trigger event to the responder object through the proxy object.

[0167] Optionally, the proxy object holds a responder list, and the proxy object forwards the trigger event to the responders recorded in the responder list. In one possible implementation, the terminal forwards the trigger event to the responder object through the proxy object, including: obtaining a responder list through the proxy object, the responder list is used to record the responders who process the trigger event; when the responder list includes the responder object, forwarding the trigger event to the responder object through the proxy object.

[0168] Optionally, before obtaining the responder list through the proxy object, the method also includes: binding the proxy object and the responder object to the list class; when loading any list page, adding the controller of the list page and the responder object bound to the list class to the responder list through the proxy object bound to the list class.

[0169] It should be noted that the responder object in step 802 is similar to the event processing object in step 302 and will not be described in detail here. The only difference is that the responder object no longer forwards the triggering event to other objects for processing, but handles it itself, and the responder object in step 802 includes the processing method code for processing any triggering event.

[0170] Another point that needs to be explained is that the difference between the responder object and the event processing object is that the responder object is generated based on the responder class, which is a class set by the technician to handle the buried point. The responder class can be a component class or a non-component class. The embodiment of the present application does not limit the responder class. The event processing object is generated based on the event processing class, which is EvenHandler.

[0171] 803. The terminal runs the target processing method code corresponding to the trigger event to process the trigger event.

[0172] Step 803 is similar to step 303 and will not be described in detail here.

[0173] It should be noted that Figure 3 In the embodiment shown, the target object is a cell object, so the cell object can directly obtain the cell data (for example, display content, etc.), and the cell object directly runs the target processing method code to process the obtained cell data. Figure 8 In the embodiment shown, the target object is a responder object, and the responder object also needs to obtain the cell data from the cell object. In a possible implementation, the terminal runs the target processing method code corresponding to the trigger event through the responder object to process the trigger event, including: the terminal obtains the cell data from the cell object corresponding to the cell identifier based on the cell identifier in the trigger event through the responder object, and runs the target processing method code to process the obtained cell data.

[0174] 804. The terminal obtains the embedded point data through the embedded point code at the target processing method code.

[0175] The step 804 is the same as the step 204 and will not be described in detail here.

[0176] 805. The terminal forwards the trigger event to the controller of the list page through the proxy object.

[0177] The step 805 is the same as the step 305 and will not be described in detail here.

[0178] 806. The terminal processes the trigger event through the controller and updates the list page.

[0179] The step 806 is the same as the step 306 and will not be described in detail here.

[0180] The data acquisition method provided in the embodiment of the present application provides a responder object, which includes a processing method code for processing any trigger event of a cell. Therefore, the responder object can process the trigger event of any list page. Therefore, it is only necessary to add the embedding code in the responder object to record the events occurring in any list page, which reduces the number of embedding codes, reduces labor costs, and improves R&D efficiency.

[0181] It should be noted that in an embodiment of the present application, when the target object is a cell object, the proxy object can directly forward the trigger event to the target object, or forward the trigger event to the target object through an event processing object; and when the target object is an event processing object or a responder object, the proxy object can directly forward the trigger event to the target object without the need for transfer through other objects.

[0182] In addition, when the target object is a cell object, if the proxy object directly forwards the trigger event to the target object, the proxy object needs to forward the trigger event to the corresponding cell object based on the cell targeted by the trigger event, which places higher requirements on the proxy object; when the target object is an event processing object or a responder object, the proxy object does not need to consider the cell targeted by the trigger event, and can directly forward the trigger event to the target object, which places lower requirements on the proxy object.

[0183] In addition, when the target object is a cell object, the target object can directly obtain the corresponding source data, and then run the corresponding processing method code to process the source data. In addition, when the target object is a cell object or a responder object, the target object also needs to obtain the corresponding source data from the corresponding cell object, and then run the corresponding processing method code to process the source data.

[0184] Fig. 9 is a structural diagram of a data acquisition device provided by the present application. Fig. 9 , the device comprises:

[0185] The first acquisition module 901 is used to acquire a triggering event for a cell in any list page through a proxy object;

[0186] A forwarding module 902, configured to forward the trigger event to a target object through the proxy object, wherein the target object includes a processing method code for processing any trigger event of a cell, wherein the processing method code includes a buried point code;

[0187] An operation module 903 is used to execute the target processing method code corresponding to the trigger event to process the trigger event;

[0188] The second acquisition module 904 is used to acquire the embedded point data through the embedded point code in the target processing method code.

[0189] like Fig.10 As shown, in a possible implementation, the trigger event carries the cell identifier of the triggered cell, and the target object is a cell object;

[0190] The forwarding module 902 is used to forward the trigger event to the cell object corresponding to the cell identifier based on the cell identifier through the proxy object.

[0191] In a possible implementation, the forwarding module 902 includes:

[0192] The object determination unit 9021 is used to determine the cell object corresponding to the cell identifier based on the cell identifier in the trigger event through the proxy object;

[0193] The protocol acquisition unit 9022 is used to acquire the protocol followed by the cell object, and the protocol is used to define the processing method code for the trigger event;

[0194] Forwarding unit 9023 is used to forward the trigger event to the cell object corresponding to the cell identifier when the protocol followed by the cell object is the target protocol. The processing method code defined by the target protocol is the same as the processing method code in the controller of the list page. The controller is used to handle any trigger event of the list page.

[0195] In a possible implementation, the object determination unit 9021 is used to forward the trigger event to the event processing object through the proxy object; determine the cell object corresponding to the cell identifier based on the cell identifier in the trigger event through the event processing object;

[0196] The forwarding unit 9023 is used to forward the trigger event to the cell object corresponding to the cell identifier through the event processing object when the protocol followed by the cell object is the target protocol.

[0197] In one possible implementation, the target object is an event processing object, which is used to process a triggering event; the forwarding module 902 is used to forward the triggering event to the event processing object through the proxy object, so that the target processing method code in the event processing object processes the triggering event.

[0198] In a possible implementation, the forwarding module 902 includes:

[0199] The protocol acquisition unit 9022 is used to acquire the protocol followed by the event processing object, and the protocol is used to define the processing method code for the triggering event;

[0200] The forwarding unit 9023 is used to forward the triggering event to the event processing object through the proxy object when the protocol followed by the event processing object is the target protocol.

[0201] In one possible implementation, the forwarding unit 9023 is used to obtain a responder list through the proxy object, and the responder list is used to record the responders who process the triggering event; when the responder list includes the event processing object, the triggering event is forwarded to the event processing object through the proxy object.

[0202] In a possible implementation, the device further includes:

[0203] A binding module 905, used to bind the proxy object and the event processing object to a list class;

[0204] The adding module 906 is used to add the controller of the list page and the event processing object bound to the list class to the responder list through the proxy object bound to the list class when any list page is loaded.

[0205] In a possible implementation, the cell triggering event carries a cell identifier of a triggered cell, and the target object is an event processing object;

[0206] The running module 903 is used to obtain the target data in the cell corresponding to the cell identifier from the cell class based on the cell identifier; and run the target processing method code corresponding to the triggering event to process the target data.

[0207] In a possible implementation, the target object is a responder object, the responder object is an object created based on a responder class, and the responder class is a class used to process buried points;

[0208] The forwarding module 902 is used to forward the trigger event to the responder object through the proxy object.

[0209] In a possible implementation, the device further includes:

[0210] The forwarding module 902 is further configured to forward the trigger event to the controller of the list page through the proxy object;

[0211] The processing module 907 is used to process the trigger event through the controller and update the list page.

[0212] An embodiment of the present application further provides a computer device, which includes a processor and a memory, wherein at least one program code is stored in the memory, and the at least one program code is loaded and executed by the processor to implement the operations performed in the data acquisition method of the above embodiment.

[0213] Optionally, the computer device is provided as a terminal. Fig.11 1 is a schematic diagram of the structure of a terminal provided in an embodiment of the present application. The terminal 1100 may be a portable mobile terminal, such as a smart phone, a tablet computer, an MP3 player (Moving Picture Experts Group Audio Layer III), an MP4 player (Moving Picture Experts Group Audio Layer IV), a laptop computer or a desktop computer. The terminal 1100 may also be referred to as a user device, a portable terminal, a laptop terminal, a desktop terminal or other names.

[0214] The terminal 1100 includes a processor 1101 and a memory 1102 .

[0215] The processor 1101 may include one or more processing cores, such as a 4-core processor, an 8-core processor, etc. The processor 1101 may be implemented in at least one hardware form of DSP (Digital Signal Processing), FPGA (Field-Programmable Gate Array), and PLA (Programmable Logic Array). The processor 1101 may also include a main processor and a coprocessor. The main processor is a processor for processing data in the awake state, also known as a CPU (Central Processing Unit); the coprocessor is a low-power processor for processing data in the standby state. In some embodiments, the processor 1101 may be integrated with a GPU (Graphics Processing Unit), which is responsible for rendering and drawing the content to be displayed on the display screen. In some embodiments, the processor 1101 may also include an AI (Artificial Intelligence) processor, which is used to process computing operations related to machine learning.

[0216] The memory 1102 may include one or more computer-readable storage media, which may be non-transitory. The memory 1102 may also include a high-speed random access memory, and a non-volatile memory, such as one or more disk storage devices, flash memory storage devices. In some embodiments, the non-transitory computer-readable storage medium in the memory 1102 is used to store at least one program code, which is used to be executed by the processor 1101 to implement the data acquisition method provided in the method embodiment of the present application.

[0217] In some embodiments, the terminal 1100 may also optionally include: a peripheral device interface 1103 and at least one peripheral device. The processor 1101, the memory 1102 and the peripheral device interface 1103 may be connected via a bus or a signal line. Each peripheral device may be connected to the peripheral device interface 1103 via a bus, a signal line or a circuit board. Specifically, the peripheral device includes: at least one of a radio frequency circuit 1104, a display screen 1105, a camera assembly 1106, an audio circuit 1107, a positioning assembly 1108 and a power supply 1109.

[0218] The peripheral device interface 1103 may be used to connect at least one peripheral device related to I / O (Input / Output) to the processor 1101 and the memory 1102. In some embodiments, the processor 1101, the memory 1102, and the peripheral device interface 1103 are integrated on the same chip or circuit board; in some other embodiments, any one or two of the processor 1101, the memory 1102, and the peripheral device interface 1103 may be implemented on a separate chip or circuit board, which is not limited in this embodiment.

[0219] The radio frequency circuit 1104 is used to receive and transmit RF (Radio Frequency) signals, also known as electromagnetic signals. The radio frequency circuit 1104 communicates with the communication network and other communication devices through electromagnetic signals. The radio frequency circuit 1104 converts electrical signals into electromagnetic signals for transmission, or converts received electromagnetic signals into electrical signals. Optionally, the radio frequency circuit 1104 includes: an antenna system, an RF transceiver, one or more amplifiers, a tuner, an oscillator, a digital signal processor, a codec chipset, a user identity module card, etc. The radio frequency circuit 1104 can communicate with other terminals through at least one wireless communication protocol. The wireless communication protocol includes but is not limited to: the World Wide Web, a metropolitan area network, an intranet, various generations of mobile communication networks (2G, 3G, 4G and 20G), a wireless local area network and / or a WiFi (Wireless Fidelity) network. In some embodiments, the radio frequency circuit 1104 may also include circuits related to NFC (Near Field Communication), which is not limited in this application.

[0220] The display screen 1105 is used to display a UI (User Interface). The UI may include graphics, text, icons, videos, and any combination thereof. When the display screen 1105 is a touch display screen, the display screen 1105 also has the ability to collect touch signals on the surface or above the surface of the display screen 1105. The touch signal can be input to the processor 1101 as a control signal for processing. At this time, the display screen 1105 can also be used to provide virtual buttons and / or virtual keyboards, also known as soft buttons and / or soft keyboards. In some embodiments, the display screen 1105 can be one, set on the front panel of the terminal 1100; in other embodiments, the display screen 1105 can be at least two, respectively set on different surfaces of the terminal 1100 or in a folding design; in other embodiments, the display screen 1105 can be a flexible display screen, set on a curved surface or a folding surface of the terminal 1100. Even, the display screen 1105 can also be set to a non-rectangular irregular shape, that is, a special-shaped screen. The display screen 1105 can be made of materials such as LCD (Liquid Crystal Display) and OLED (Organic Light-Emitting Diode).

[0221] The camera assembly 1106 is used to capture images or videos. Optionally, the camera assembly 1106 includes a front camera and a rear camera. The front camera is arranged on the front panel of the terminal, and the rear camera is arranged on the back of the terminal. In some embodiments, there are at least two rear cameras, which are any one of a main camera, a depth of field camera, a wide-angle camera, and a telephoto camera, so as to realize the fusion of the main camera and the depth of field camera to realize the background blur function, the fusion of the main camera and the wide-angle camera to realize panoramic shooting and VR (Virtual Reality) shooting function or other fusion shooting functions. In some embodiments, the camera assembly 1106 may also include a flash. The flash can be a monochrome temperature flash or a dual-color temperature flash. A dual-color temperature flash refers to a combination of a warm light flash and a cold light flash, which can be used for light compensation at different color temperatures.

[0222] The audio circuit 1107 may include a microphone and a speaker. The microphone is used to collect sound waves from the user and the environment, and convert the sound waves into electrical signals and input them into the processor 1101 for processing, or input them into the radio frequency circuit 1104 to achieve voice communication. For the purpose of stereo acquisition or noise reduction, there may be multiple microphones, which are respectively arranged at different parts of the terminal 1100. The microphone may also be an array microphone or an omnidirectional acquisition microphone. The speaker is used to convert the electrical signal from the processor 1101 or the radio frequency circuit 1104 into sound waves. The speaker may be a traditional film speaker or a piezoelectric ceramic speaker. When the speaker is a piezoelectric ceramic speaker, it can not only convert the electrical signal into sound waves audible to humans, but also convert the electrical signal into sound waves inaudible to humans for purposes such as ranging. In some embodiments, the audio circuit 1107 may also include a headphone jack.

[0223] The positioning component 1108 is used to locate the current geographical location of the terminal 1100 to implement navigation or LBS (Location Based Service). The positioning component 1108 can be based on the US GPS (Global Positioning System), China's Beidou system or Russia's Grenas positioning system and the European Union's Galileo positioning system.

[0224] The power supply 1109 is used to power various components in the terminal 1100. The power supply 1109 can be an alternating current, a direct current, a disposable battery, or a rechargeable battery. When the power supply 1109 includes a rechargeable battery, the rechargeable battery can be a wired rechargeable battery or a wireless rechargeable battery. A wired rechargeable battery is a battery charged through a wired line, and a wireless rechargeable battery is a battery charged through a wireless coil. The rechargeable battery can also be used to support fast charging technology.

[0225] In some embodiments, the terminal 1100 further includes one or more sensors 1110 , including but not limited to: an acceleration sensor 1111 , a gyroscope sensor 1112 , a pressure sensor 1113 , a fingerprint sensor 1114 , an optical sensor 1115 , and a proximity sensor 1116 .

[0226] The acceleration sensor 1111 can detect the magnitude of acceleration on the three coordinate axes of the coordinate system established by the terminal 110. For example, the acceleration sensor 1111 can be used to detect the components of gravity acceleration on the three coordinate axes. The processor 1101 can control the display screen 1105 to display the user interface in a horizontal view or a vertical view according to the gravity acceleration signal collected by the acceleration sensor 1111. The acceleration sensor 1111 can also be used to collect motion data of games or users.

[0227] The gyro sensor 1112 can detect the body direction and rotation angle of the terminal 1100, and the gyro sensor 1112 can cooperate with the acceleration sensor 1111 to collect the user's 3D actions on the terminal 1100. The processor 1101 can implement the following functions based on the data collected by the gyro sensor 1112: motion sensing (such as changing the UI according to the user's tilt operation), image stabilization during shooting, game control, and inertial navigation.

[0228] The pressure sensor 1113 can be set on the side frame of the terminal 1100 and / or the lower layer of the display screen 1102. When the pressure sensor 1113 is set on the side frame of the terminal 1100, the user's holding signal of the terminal 1100 can be detected, and the processor 1101 performs left and right hand recognition or shortcut operations according to the holding signal collected by the pressure sensor 1113. When the pressure sensor 1113 is set on the lower layer of the display screen 1102, the processor 1101 controls the operability controls on the UI interface according to the user's pressure operation on the display screen 1105. The operability controls include at least one of a button control, a scroll bar control, an icon control, and a menu control.

[0229] The fingerprint sensor 1114 is used to collect the user's fingerprint, and the processor 1101 identifies the user's identity based on the fingerprint collected by the fingerprint sensor 1114, or the fingerprint sensor 1114 identifies the user's identity based on the collected fingerprint. When the user's identity is identified as a trusted identity, the processor 1101 authorizes the user to perform relevant sensitive operations, which include unlocking the screen, viewing encrypted information, downloading software, paying, and changing settings. The fingerprint sensor 1114 can be set on the front, back, or side of the terminal 1100. When a physical button or a manufacturer logo is set on the terminal 1100, the fingerprint sensor 1114 can be integrated with the physical button or the manufacturer logo.

[0230] The optical sensor 1115 is used to collect the ambient light intensity. In one embodiment, the processor 1101 can control the display brightness of the display screen 1105 according to the ambient light intensity collected by the optical sensor 1115. Specifically, when the ambient light intensity is high, the display brightness of the display screen 1105 is increased; when the ambient light intensity is low, the display brightness of the display screen 1105 is reduced. In another embodiment, the processor 1101 can also dynamically adjust the shooting parameters of the camera assembly 1106 according to the ambient light intensity collected by the optical sensor 1115.

[0231] The proximity sensor 1116, also called a distance sensor, is disposed on the front panel of the terminal 1100. The proximity sensor 1116 is used to collect the distance between the user and the front of the terminal 1100. In one embodiment, when the proximity sensor 1116 detects that the distance between the user and the front of the terminal 1100 is gradually decreasing, the processor 1101 controls the display screen 1105 to switch from the screen-on state to the screen-off state; when the proximity sensor 1116 detects that the distance between the user and the front of the terminal 1100 is gradually increasing, the processor 1101 controls the display screen 1105 to switch from the screen-off state to the screen-on state.

[0232] Those skilled in the art will understand that Fig.11 The structure shown in the figure does not constitute a limitation on the terminal 1100, and the terminal 1100 may include more or fewer components than those shown in the figure, or combine certain components, or adopt a different component arrangement.

[0233] Optionally, the computer device is provided as a server. Fig.12 This is a schematic diagram of the structure of a server according to an exemplary embodiment. The server 1200 may have relatively large differences due to different configurations or performances, and may include one or more processors (Central Processing Units, CPU) 1201 and one or more memories 1202, wherein the memory 1202 stores at least one program code, and the at least one program code is loaded and executed by the processor 1201 to implement the methods provided by the above-mentioned various method embodiments. Of course, the server may also have components such as a wired or wireless network interface, a keyboard, and an input and output interface for input and output, and the server may also include other components for implementing device functions, which will not be described in detail here.

[0234] An embodiment of the present application further provides a computer-readable storage medium, in which at least one program code is stored. The at least one program code is loaded and executed by a processor to implement the operations performed in the data acquisition method of the above embodiment.

[0235] The embodiment of the present application further provides a computer program product, in which at least one program code is stored. The at least one program code is loaded and executed by a processor to implement the operations performed in the data acquisition method of the above embodiment.

[0236] A person skilled in the art will understand that all or part of the steps to implement the above embodiments may be accomplished by hardware or by instructing related hardware through a program, and the program may be stored in a computer-readable storage medium, and the above-mentioned storage medium may be a read-only memory, a disk or an optical disk, etc.

[0237] The above are only optional embodiments of the embodiments of the present application and are not intended to limit the embodiments of the present application. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the embodiments of the present application should be included in the protection scope of the present application.

Claims

1. A data acquisition method, characterized in that: The method comprises: Get the trigger event of the cell in any list page through the proxy object; Acquire a responder list through the proxy object, the responder list is used to record the responders who process the trigger event; if the responder list includes an event processing object, forward the trigger event to the event processing object through the proxy object; the event processing object is used to process the trigger event; The target object is a cell object, the trigger event carries a cell identifier of the triggered cell, and the cell object includes the source code of the cell; through the event processing object, based on the cell identifier in the trigger event, the cell object corresponding to the cell identifier is determined; the trigger event is forwarded to the cell object corresponding to the cell identifier; or, The target object is an event processing object, and the trigger event is forwarded to the event processing object through the proxy object, so as to enable the target processing method code in the event processing object to process the trigger event; The target object includes a processing method code for processing any trigger event of a cell, and a embedding code is set in the processing method code; Run the target processing method code corresponding to the trigger event to process the trigger event; The embedded point data is obtained through the embedded point code in the target processing method code.

2. The method according to claim 1, characterized in that The forwarding the trigger event to the cell object corresponding to the cell identifier includes: Obtaining the protocol followed by the cell object, wherein the protocol is used to define a processing method code for a triggering event; When the protocol followed by the cell object is the target protocol, the trigger event is forwarded to the cell object corresponding to the cell identifier. The processing method code defined by the target protocol is the same as the processing method code in the controller of the list page. The controller is used to handle any trigger event of the list page.

3. The method according to claim 2, characterized in that When the protocol followed by the cell object is the target protocol, forwarding the trigger event to the cell object corresponding to the cell identifier includes: In a case where the protocol followed by the cell object is the target protocol, the trigger event is forwarded to the cell object corresponding to the cell identifier through the event processing object.

4. The method according to claim 1, characterized in that The target object is an event processing object, and forwarding the trigger event to the event processing object through the proxy object includes: Obtaining the protocol followed by the event processing object, wherein the protocol is used to define the processing method code for the triggering event; In the case that the protocol followed by the event processing object is the target protocol, the trigger event is forwarded to the event processing object through the proxy object.

5. The method according to claim 1, characterized in that: Before obtaining the responder list through the proxy object, the method further includes: Binding the proxy object and the event processing object to the list class; When any list page is loaded, the controller of the list page and the event processing object bound to the list class are added to the responder list through the proxy object bound to the list class.

6. The method according to claim 1, characterized in that The trigger event carries the cell identifier of the triggered cell, and the target object is an event processing object; The running of the target processing method code corresponding to the triggering event to process the triggering event includes: Based on the cell identifier, obtaining target data in the cell corresponding to the cell identifier from the cell class; The target processing method code corresponding to the triggering event is run to process the target data.

7. The method according to claim 1, characterized in that The target object is a responder object, which is an object created based on a responder class, and the responder class is a class used to process buried points; The method further comprises: The trigger event is forwarded to the responder object through the proxy object.

8. The method according to claim 1, characterized in that After obtaining the triggering event of a cell in any list page through the proxy object, the method further includes: Forwarding the trigger event to the controller of the list page through the proxy object; The trigger event is processed by the controller to update the list page.

9. A data acquisition device, characterized in that: The device comprises: A first acquisition module is used to acquire a triggering event for a cell in any list page through a proxy object; The forwarding module includes a forwarding unit; the forwarding unit is used to obtain a responder list through the proxy object, and the responder list is used to record responders who process the triggering event; if the responder list includes an event processing object, the triggering event is forwarded to the event processing object through the proxy object; the event processing object is used to process the triggering event; The target object is a cell object, the trigger event carries a cell identifier of the triggered cell, the cell object includes the source code of the cell, and the forwarding module further includes an object determination unit; the object determination unit is used to determine the cell object corresponding to the cell identifier based on the cell identifier in the trigger event through the event processing object; the forwarding unit is used to forward the trigger event to the cell object corresponding to the cell identifier; or, The target object is an event processing object, and the trigger event is forwarded to the event processing object through the proxy object, so as to enable the target processing method code in the event processing object to process the trigger event; The target object includes a processing method code for processing any trigger event of a cell, and a embedding code is set in the processing method code; An operation module, used for executing a target processing method code corresponding to the trigger event to process the trigger event; The second acquisition module is used to acquire the embedded point data through the embedded point code in the target processing method code.

10. A computer device, characterized in that: The computer device includes a processor and a memory, wherein the memory stores at least one program code, and the at least one program code is loaded and executed by the processor to implement the operations performed in the data acquisition method according to any one of claims 1 to 8.

11. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores at least one program code, and the at least one program code is loaded and executed by a processor to implement the operations performed in the data acquisition method according to any one of claims 1 to 8.

12. A computer program product, characterized in that The computer program product stores at least one program code, and the at least one program code is loaded and executed by a processor to implement the operations performed in the data acquisition method according to any one of claims 1 to 8.

Images