CN115454770A

CN115454770A - Reporting method and device of embedded point information, storage medium and electronic equipment

Info

Publication number: CN115454770A
Application number: CN202211125157.8A
Authority: CN
Inventors: 陈锦海; 曹偲; 丁立; 余英豪; 张腾飞
Original assignee: Hangzhou Netease Cloud Music Technology Co Ltd
Current assignee: Hangzhou Netease Cloud Music Technology Co Ltd
Priority date: 2022-09-14
Filing date: 2022-09-14
Publication date: 2022-12-09

Abstract

The disclosed embodiments relate to a reporting method of embedded point information, a reporting device of embedded point information, a computer readable storage medium, and an electronic device, and relate to the technical field of computers. The reporting method of the embedded point information comprises the following steps: responding to a trigger operation aiming at a client, and determining a page node tree of a target display page exposed by the trigger operation; generating a buried point object tree according to the attribute information of the nodes in the page node tree; and determining a buried point object to be reported based on the generated adjacent buried point object tree, and reporting buried point information according to the buried point object to be reported. The method and the device can improve efficiency and accuracy of reporting the buried point information based on the generated adjacent buried point object tree.

Description

Reporting method and device of embedded point information, storage medium and electronic equipment

Technical Field

The present disclosure relates to the field of computer technologies, and in particular, to a method and an apparatus for reporting buried point information, a computer-readable storage medium, and an electronic device.

Background

This section is intended to provide a background or context to the embodiments of the disclosure recited in the claims and the description herein is not admitted to be prior art by inclusion in this section.

The buried point is a process specific in the application that collects some information to track the usage of the application to provide data support for further optimizing the product.

The point burying schemes in the prior art are mainly divided into the following 3 types: the first one is an automatic embedded point scheme based on x-path, also called a full embedded point or non-embedded point scheme, that is, the original user interface hierarchical structure of the client is utilized to describe the pit position, the embedded point information is fully reported, and the fully reported embedded point information is selectively used at the later stage according to the requirement; the second is a manual point burying scheme for precise and standard management of positions and parameters, namely, point burying parameters are manually set by developers for pit positions in a non-hierarchical context gathering manner; the third scheme is a partial buried point automation scheme based on an SPM (Super Position Model) and SCM (Super Content Model), namely, position and Content are standardized and described through a four-stage SPM (site, page block, and intra-block point location) and an SCM, developers identify and set parameters for pit positions, and information of buried points is collected in a non-hierarchical context gathering manner.

Disclosure of Invention

However, the first point burying schemes all have the problems of unstable pit bit description of the buried points and high later maintenance cost, that is, the client of each version needs to reselect the pit bit, and different types of clients may have different pit bit descriptions, so that the later maintenance and management cost of the buried points is high, and the efficiency of reporting the buried point information is low; although the second point burying scheme can better guarantee the quality of the buried points, the workload of the buried points is large, the efficiency is low, the determination cost of the time of some buried points is high, meanwhile, due to the randomness and the randomness of the pit position expression, the situation is inconsistent with the multiplexing situations of a large number of components and UIs (user interfaces) existing in the development of a large front end, a small amount of front end page changes exist, but a large number of pain points of the buried points need to be buried again; in the third point burying scheme, because a pit description method with no more than four levels of 'site-page block-block internal point position' is adopted, when the buried point data is in a complex hierarchical structure, the pit description of the scheme per se has information loss, so that the problem that the pit information description of the buried point is not accurate enough exists, the accuracy of reporting the buried point information is low, and the problem that the later maintenance and management cost of the buried point is high exists.

Therefore, an improved method for reporting the buried point information is very needed, which can improve the accuracy of reporting the buried point information and the efficiency of reporting the buried point information at the same time, and reduce the later maintenance cost of the buried point.

In this context, embodiments of the present disclosure desirably provide a method and an apparatus for reporting embedded point information, a computer-readable storage medium, and an electronic device.

According to a first aspect of the embodiments of the present disclosure, a method for reporting buried point information is provided, including: responding to a trigger operation aiming at a client, and determining a page node tree of a target display page exposed by the trigger operation; generating a buried point object tree according to the attribute information of the nodes in the page node tree; and determining a buried point object to be reported based on the generated adjacent buried point object tree, and reporting buried point information according to the buried point object to be reported.

In an optional embodiment, the determining a page node tree of a target display page exposed by the trigger operation includes: and determining a page node tree of the target display page exposed by the trigger operation according to the interface hierarchical relationship of the target display page exposed by the trigger operation.

In an optional implementation manner, the generating a buried object tree according to the attribute information of the node in the page node tree includes: generating a buried point object tree according to whether the target parameters are configured in the nodes in the page node tree or not; the target parameter is used for indicating that the node is a buried point object.

In an optional implementation manner, the generating a buried object tree according to whether a node in the page node tree is configured with the target parameter includes: traversing the page node tree starting from a root node of the page node tree; determining a first target node according to the node configured with the target parameter in the page node tree; generating a buried object tree based on the first target node.

In an optional implementation manner, the determining a first target node according to the node in the page node tree configured with the target parameter includes: and determining a first target node according to the node which is configured with the target parameter and the visibility attribute in the page node tree.

In an optional implementation manner, determining a first target node according to a node in the target node tree, where the target parameter is configured, includes: determining a first target node according to the nodes which are configured with the target parameters and do not have a preset mounting relation in the page node tree; the preset mount relation is used for indicating the parent-child relation of the node in the buried point object tree.

In an alternative embodiment, the generating a buried object tree based on the first target node includes: generating an initial buried object tree based on the parent-child relationship of each first target node in the page node tree; adjusting the initial buried point object tree according to a preset mount node associated with a first target node in the initial buried point object tree to generate the buried point object tree; the preset mount node and a first target node in the buried point object tree have a first preset parent-child relationship, the preset mount node comprises one or more of a node for representing a preset event, a node which exists in the page node tree and has a first preset parent-child relationship with any one of the first target nodes, and a node which does not exist in the page node tree and has a first preset parent-child relationship with any one of the first target nodes, when the preset mount node exists in the page node tree, the first preset parent-child relationship is different from a second preset parent-child relationship, and the second preset parent-child relationship comprises the parent-child relationship of the preset mount node in the page node tree.

In an alternative embodiment, said traversing said page node tree starting from a root node of said page node tree comprises: and when the traversed node is configured with the invisible attribute, not traversing the child nodes of the node.

In an optional embodiment, the determining a to-be-reported buried point object based on the generated adjacent buried point object trees includes: determining visible nodes in the first buried point object tree and the second buried point object tree; determining a buried point object to be reported according to the visible node; the first buried object tree is a buried object tree generated earlier in the adjacent buried object trees, the second buried object tree is a buried object tree generated later in the adjacent buried object trees, and the buried object indicated by the visible node is not completely blocked in the graphical user interface.

In an optional implementation manner, the determining, according to the visible node, a buried point object to be reported includes: for any visible node, if the visible node appears in the first buried point object tree and does not appear in the second buried point object tree, determining that the buried point object indicated by the visible node is a first buried point object to be reported; and for any visible node, if the visible node appears in the second buried point object tree and does not appear in the first buried point object tree, determining that the buried point object indicated by the visible node is a second buried point object to be reported.

In an optional implementation manner, the determining, according to the visible node, a to-be-reported buried point object includes: for any of the visible nodes, determining a first number of occurrences of the visible node in the first buried object tree and a second number of occurrences in the second buried object tree, respectively; and determining a buried point object to be reported according to the first occurrence frequency and the second occurrence frequency of each visible node.

In an optional implementation manner, determining a buried point object to be reported according to the first occurrence number and the second occurrence number of each visible node includes: when the first occurrence number is greater than 0 and the second occurrence number is equal to 0, determining that the buried point object indicated by the visible node is a first buried point object to be reported; and when the first occurrence number is equal to 0 and the second occurrence number is greater than 0, determining that the buried point object indicated by the visible node is a second to-be-buried point object.

In an alternative embodiment, the visible node is determined by: traversing a buried object tree, and acquiring a father node of a second target node when a currently traversed node is the second target node, wherein the second target node is a page type node; determining a node to be processed corresponding to the second target node in the buried object tree according to the type of the father node; determining invisible nodes in the nodes to be processed based on the first display area and the second display area; determining visible nodes in the buried point object tree according to invisible nodes in the buried point object tree; the first display area is a display area of a buried point object indicated by the traversed page type node in a graphical user interface, and the second display area is a display area of the current node to be processed in the graphical user interface.

In an optional implementation manner, the determining, according to the type of the parent node, a node to be processed corresponding to the second target node in the buried object tree includes: when the type of the father node is a page type, determining a node to be processed corresponding to the second target node by the following method: determining a node to be processed corresponding to the second target node according to a node which is positioned in the same level as the second target node in the embedded point object tree and is positioned on the left of the second target node and sub-nodes thereof; when the type of the father node is an element type, determining a node to be processed corresponding to the second target node by the following method: determining a first node to be processed according to a node which is positioned in the same level as the second target node in the buried point object tree and positioned on the left side of the second target node and child nodes thereof; determining a second node to be processed according to a node which is in the same level with the father node and is positioned on the left side of the father node in the buried point object tree; repeatedly executing the step of searching the father node of the father node, when the searched current father node is a third target node of the element type, determining a third node to be processed according to a node which is positioned at the same level in the buried point object tree as the third target node and is positioned at the left side of the third target node, and stopping searching when the searched current father node is of the page type or the father node is not searched currently; and determining a node to be processed corresponding to the second target node according to the first node to be processed, the second node to be processed and the third node to be processed.

In an optional implementation manner, the determining, based on the first display area and the second display area, an invisible node in the nodes to be processed includes: when it is determined that the first display area and the second display area have an overlapping portion and the display size of the overlapping portion is equal to that of the second display area, determining that the to-be-processed node corresponding to the second display area is an invisible node.

In an optional implementation manner, the reporting of the buried point information according to the buried point object to be reported includes: determining a buried point object identification chain from the node corresponding to the buried point object to be reported to a root node in the buried point object tree based on the parent-child relationship of the node corresponding to the buried point object to be reported in the buried point object tree and a buried point object identification configured for the buried point object to be reported in advance; adding the position attribute information of the buried point object to be reported to the buried point object identification chain to obtain pit bit information of the buried point object to be reported; and reporting the buried point information of the buried point object to be reported according to the pit bit information of the buried point object to be reported.

In an optional implementation manner, the generating a buried object tree according to the attribute information of the nodes in the page node tree includes: updating a first preset storage container according to the trigger operation and the root page of the target display page exposed by the trigger operation; and generating a buried object tree corresponding to the root page according to the attribute information of the nodes in the page node tree corresponding to the root page aiming at each updated root page in a first preset storage container based on a preset period.

In an optional implementation manner, the generating, based on a preset period and for each root page updated in a first preset storage container, a buried point object tree corresponding to the root page according to attribute information of a node in a page node tree corresponding to the root page includes: determining a time to be processed based on the preset period; when any one to-be-processed time arrives, if the residual time of the running cycle of the main thread of the terminal equipment where the client is located is greater than or equal to a first preset value, determining the to-be-processed time as a target time; and at the current target moment, aiming at each root page updated in the first preset storage container from the last target moment to the current target moment, and generating a buried object tree corresponding to the root page according to the attribute information of nodes in a page node tree of the root page based on an updating sequence.

In an alternative embodiment, when the triggering operation comprises a sliding operation, the method further comprises: collecting sliding messages of the sliding operation according to a first preset time interval, and updating a second preset storage container according to the collected sliding messages and child node identifications corresponding to the list to which the sliding operation aims; when the first preset storage container is not updated and the second preset storage container is updated, traversing a page node tree where the child node identifiers are located from the child node identifiers on the basis of an updating sequence aiming at the child node identifiers updated in the second preset storage container so as to generate a buried point object tree; when the first preset storage container is updated, for each updated root page in the first preset storage container, traversing a page node tree corresponding to the root page from a node corresponding to the root page based on an updating sequence to generate a buried point object tree.

According to a second aspect of the embodiments of the present disclosure, there is provided a reporting apparatus for reporting embedded point information, including: the page node tree determining module is configured to determine a page node tree of a target display page exposed by a trigger operation in response to the trigger operation for a client; a buried object tree generating module configured to generate a buried object tree according to attribute information of nodes in the page node tree; and the buried point information reporting module is configured to determine a buried point object to be reported based on the generated adjacent buried point object tree, so as to report the buried point information according to the buried point object to be reported.

According to a third aspect of the disclosed embodiments, a computer-readable storage medium is provided, where a computer program is stored, and when the computer program is executed by a processor, the reporting method of the buried point information in the first aspect is implemented.

According to a fourth aspect of the disclosed embodiments, there is provided an electronic device comprising: a processor; and a memory for storing executable instructions of the processor; the processor is configured to execute the executable instructions to perform the reporting method of the buried point information according to the first aspect.

According to the reporting method of the embedded point information, the reporting device of the embedded point information, the computer readable storage medium and the electronic device of the embodiment of the disclosure, the embedded point object tree can be generated by the attribute information of the page node tree of the target display page exposed by the trigger operation aiming at the client, so that the embedded point object to be reported can be determined based on the generated adjacent embedded point object trees, and then the embedded point information can be reported according to the embedded point object to be reported. On one hand, according to the method and the device, the embedded point object tree for reporting the embedded point information can be automatically generated through the attribute information of the nodes of the page node tree, the consistency of the reporting of the embedded point information of different clients can be ensured, and the maintenance cost of the embedded points is reduced; on the other hand, the buried point object to be reported can be automatically determined based on the generated adjacent buried point object tree, so that the automatic detection of buried point exposure is realized, and the reporting efficiency of buried point information is improved; on the other hand, compared with the four-level pit bit description in the related technology, the embedded point object tree used for reporting the embedded point information is generated according to the attribute information of the page node tree of the target display page exposed by the trigger operation, and the embedded point object tree can be generated according to the attribute information of the page node tree under the condition that the page level is complex, so that the position of the embedded point can be more accurately described through the embedded point object tree, and the accuracy of reporting the embedded point information is improved.

Drawings

The above and other objects, features and advantages of exemplary embodiments of the present disclosure will become readily apparent from the following detailed description read in conjunction with the accompanying drawings. Several embodiments of the present disclosure are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which:

fig. 1 is a schematic flow chart illustrating a reporting method of embedded point information according to an embodiment of the present disclosure;

FIG. 2 illustrates a schematic diagram of a method of generating a buried point object tree according to an embodiment of the present disclosure;

FIG. 3 is a schematic diagram illustrating a page requiring a logical mount according to an embodiment of the present disclosure;

FIG. 4 is a schematic diagram of a page requiring the addition of virtual nodes according to an embodiment of the present disclosure;

FIG. 5 shows a schematic diagram of a logical mount process according to an embodiment of the present disclosure;

FIG. 6 illustrates a flow diagram of another method of generating a buried point object tree in accordance with an embodiment of the present disclosure;

fig. 7 is a flowchart illustrating a method for determining a buried object to be reported according to an embodiment of the disclosure;

FIG. 8 illustrates a schematic diagram of a truly visible region of an object, in accordance with embodiments of the present disclosure;

FIG. 9 is a schematic diagram illustrating an inter-object occlusion scenario in accordance with an embodiment of the present disclosure;

FIG. 10 shows a schematic diagram of a node tree of a page in accordance with an embodiment of the present disclosure;

FIG. 11 illustrates a flow diagram of a method of determining visible nodes in accordance with an embodiment of the present disclosure;

FIG. 12 illustrates a schematic diagram of a buried point object tree, according to an embodiment of the present disclosure;

fig. 13 is a flowchart illustrating a method of determining a node to be processed corresponding to a second target node in a case that a parent node of the second target node is a node of an element type according to an embodiment of the present disclosure;

fig. 14 is a schematic flowchart illustrating a method for determining a to-be-reported buried point object according to a visible node according to an embodiment of the present disclosure;

FIG. 15 illustrates a schematic diagram of a neighborhood buried object tree, according to an embodiment of the present disclosure;

FIG. 16 is a diagram illustrating a traversal result of a buried object tree according to an embodiment of the present disclosure;

fig. 17 is a schematic workflow diagram illustrating a method for reporting embedded point information according to an embodiment of the present disclosure;

FIG. 18 is a schematic flow chart diagram illustrating yet another method of generating a buried point object tree according to an embodiment of the present disclosure;

FIG. 19 is a flowchart illustrating a method for generating a buried point object tree corresponding to a root page according to an embodiment of the disclosure;

FIG. 20 is a schematic flow chart diagram illustrating yet another method of generating a buried point object tree in accordance with an embodiment of the present disclosure;

fig. 21 is a schematic diagram illustrating a process of performing work current limitation on reporting of embedded point information according to an embodiment of the present disclosure;

fig. 22 is a flowchart illustrating a method for reporting buried point information according to a buried point object to be reported according to an embodiment of the present disclosure;

fig. 23 is a schematic structural diagram of a reporting apparatus for buried point information according to an embodiment of the present disclosure;

fig. 24 shows a block diagram of an electronic device according to an embodiment of the present disclosure.

In the drawings, the same or corresponding reference numerals indicate the same or corresponding parts.

Detailed Description

The principles and spirit of the present disclosure will be described with reference to a number of exemplary embodiments. It is understood that these embodiments are presented merely to enable those skilled in the art to better understand and to practice the disclosure, and are not intended to limit the scope of the disclosure in any way. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

As will be appreciated by one skilled in the art, embodiments of the present disclosure may be embodied as a system, apparatus, device, method, or computer program product. Accordingly, the present disclosure may be embodied in the form of: entirely hardware, entirely software (including firmware, resident software, micro-code, etc.), or a combination of hardware and software.

According to an embodiment of the present disclosure, a reporting method of embedded point information, a reporting device of embedded point information, a computer-readable storage medium, and an electronic device are provided.

In this document, any number of elements in the drawings is by way of example and not by way of limitation, and any nomenclature is used solely for differentiation and not by way of limitation.

The principles and spirit of the present disclosure are explained in detail below with reference to several representative embodiments of the present disclosure.

Summary of The Invention

The inventor of the present disclosure finds that, in some existing point burying schemes, for clients of different versions or clients corresponding to different operating systems, there is a problem of inconsistent pit location description of a buried point, which causes instability of pit location information description of the buried point, and when a new version of a client is updated each time, pit location information of the buried point needs to be comprehensively checked and reselected, thereby resulting in high later maintenance cost of the buried point; in other existing point burying schemes, the problem that description of pit position information of a buried point is inaccurate exists, so that accuracy of reporting the buried point information is low, the buried point information cannot be automatically reported, and reporting efficiency of the buried point information is low.

In view of the above, the basic idea of the present disclosure is: the method comprises the steps of generating a buried point object tree by aiming at attribute information of a page node tree of a target display page exposed by triggering operation of a client, determining a buried point object to be reported based on the generated adjacent buried point object tree, and reporting the buried point information according to the buried point object to be reported. On one hand, according to the method and the device, the embedded point object tree for reporting the embedded point information can be automatically generated through the attribute information of the nodes of the page node tree, the consistency of the reporting of the embedded point information of different clients can be ensured, and the maintenance cost of the embedded points is reduced; on the other hand, the method can automatically determine the buried point object to be reported based on the generated adjacent buried point object tree so as to realize the automatic detection of the buried point exposure and improve the reporting efficiency of the buried point information; on the other hand, compared with the four-level pit bit description in the related technology, the embedded point object tree for reporting the embedded point information can be generated according to the attribute information of the page node tree of the target display page exposed by the trigger operation, and the embedded point object tree can be generated according to the attribute information of the page node tree under the condition that the page level is complex, so that the position of the embedded point can be more accurately described through the embedded point object tree, and the accuracy of reporting the embedded point information is improved.

Having described the general principles of the present disclosure, various non-limiting embodiments of the present disclosure are described in detail below.

Application scene overview

It should be noted that the following application scenarios are merely illustrated to facilitate understanding of the spirit and principles of the present disclosure, and embodiments of the present disclosure are not limited in this respect. Rather, embodiments of the present disclosure may be applied to any scenario where applicable.

The present disclosure may be applied to scenarios where data is collected, for example: the embedded point information reporting method provided by the disclosure can be used for collecting the use data (such as access number, visitor number, dwell time, page browsing number and the like) of the application, and tracking the use condition of the application based on the use data so as to provide data support for further optimization of the application; in an information recommendation scene, the relevant historical behavior data of a user can be collected by using the buried point information reporting method provided by the disclosure, and then the user portrait can be described based on the collected historical behavior data of the user so as to recommend information to the user.

Exemplary method

In the point burying scheme in the related art, for clients of different versions or clients corresponding to different operating systems, the problem of inconsistent pit position description of the buried point exists, so that the pit position information description of the buried point is unstable, and the pit position information of the buried point needs to be comprehensively checked and reselected each time a new version of the client is updated, thereby causing high later maintenance cost of the buried point; in other existing point burying schemes, the problem that description of pit position information of a buried point is inaccurate exists, so that accuracy of reporting of the buried point information is low, the buried point information cannot be automatically reported, reporting efficiency of the buried point information is low, and related development and maintenance costs of the buried point are high.

Taking internet music as an example, the internet music is a complex content community-type product, and a large number of resource distribution organization forms and internal engineering construction backgrounds exist. For example, a song list and a dynamic song list in the Internet cloud music appear in a plurality of scenes and module partitions, for example, the song list can appear in a recommended song list of a first page, the song list can also appear in a song list square, and the like. For the existing buried point management method, even if the song menu card component in the client is uniformly multiplexed, the buried point of the client can expand to a great extent along with the increase of scene combination conditions, so that the buried point development has pain points in terms of workload, quality and standardization.

The exemplary embodiment of the present disclosure first provides a reporting method of buried point information, so as to overcome, at least to some extent, all or part of the above-mentioned drawbacks in the related art.

Fig. 1 shows a reporting method of embedded point information in an exemplary embodiment of the present disclosure, which may include:

step S110, responding to the trigger operation aiming at the client, and determining a page node tree of a target display page exposed by the trigger operation;

step S120, generating a buried point object tree according to the attribute information of the nodes in the page node tree;

step S130, determining a buried point object to be reported based on the generated adjacent buried point object tree, and reporting buried point information according to the buried point object to be reported.

Each step in fig. 1 will be described in detail below.

Step S110, in response to a trigger operation for a client, determining a page node tree of a target display page exposed by the trigger operation.

In an alternative embodiment, the triggering operation may include clicking, sliding, or gesture operation performed on the client, and the triggering operation may be contact type or non-contact type, and this is not limited in this exemplary embodiment.

Exposure may be understood as the change of a page or element from an invisible state to a visible state in a graphical user interface of a client. The target display page may include any display page in the client, which corresponds to the trigger operation, for example, if the user clicks the button 1 in the client, the page displayed in the client jumps from the page 1 before the click to the page 2, and the page 2 is the target display page exposed by the trigger operation of clicking the button 1. Corresponding to the exposure is a back exposure, which may be understood as a change of a page or element from a visible state to an invisible state in the graphical user interface of the client.

A page may be understood as a whole area displayed exclusively at a certain user interface level, such as a newly opened underlying page, a TAB (TAB/TAB), a channel, etc.; the page is generally used for organizing a plurality of contents to distribute or used as an actual function bearing of a single content, and information such as circulation exposure and dwell time of the page has great significance for analysis of the application. An element may be understood as a UI (User Interface) component and/or element in a page that may be interacted with by a User, such as a list element, a button, a slideable content module, etc. The lists and modules are generally used for carrying content distribution, the click rate of the lists and modules has analytical significance on content distribution effects, the buttons are generally used for carrying user interaction, and the buttons are generally mounted on a certain content unit or a bottom page of a content function.

Both pages and elements can be considered as buried point objects. One page can comprise sub-pages and elements, for one page, the page itself, the sub-pages and the elements in the page can be used as buried point objects in the page, and a user can perform self-defined setting according to the needs of the user.

For example, the determining a page node tree of the target display page exposed by the trigger operation may include: and determining a page node tree of the target display page exposed by the trigger operation according to the interface hierarchical relationship of the target display page exposed by the trigger operation.

For example, when a front-end developer develops a front-end user interface, the front-end developer may configure an interface hierarchical relationship of a front-end page, and may determine a page node tree of the front-end page according to the interface hierarchical relationship.

Next, in step S120, a buried object tree is generated according to the attribute information of the nodes in the page node tree.

The attribute information of the node may include whether the node is configured with a buried Object identification OID (Object Id). The attribute information of the node may also include one or more of whether the node is visible, whether the node is involved in a logical mount, and the like.

In an optional implementation manner, the generating a buried object tree according to the attribute information of the nodes in the page node tree includes: generating a buried point object tree according to whether the nodes in the page node tree are configured with target parameters or not; the target parameter is used for indicating that the node is a buried point object.

For example, the target parameters may include the above-described buried object identifier. If a node in the page node tree is configured with a buried object identifier, the node can be determined to be a buried object. For example, when the client has an event such as page switching, element clicking, list sliding, etc., it may traverse downwards from the root node of the page node tree, traverse to the hierarchy configured with the OID parameter for reservation, and remove other hierarchies not configured with the OID parameter, so that the buried point object tree may be generated according to the hierarchy configured with the OID in the page node tree.

Illustratively, fig. 2 shows a schematic diagram of a method for generating a buried point object tree according to an embodiment of the present disclosure. Referring to fig. 2, the method may include steps S210 to S230.

In step S210, the page node tree is traversed starting from the root node of the page node tree.

For example, the nodes in the page node tree may be Depth-First traversed downward starting from the root node of the page node tree based on a Depth First Search (DFS) manner.

Next, in step S220, a first target node is determined according to the node of the page node tree configured with the target parameter.

As described above, the page node tree may be traversed from the root node to the hierarchy configured with the OID parameter, and the other hierarchies not configured with the OID parameter are removed, so that the buried object tree may be generated according to the hierarchies configured with the OID parameter in the page node tree.

However, there are nodes with invisible attributes in the page node tree, these nodes are invisible, they are not displayed in the front page, the user naturally cannot perceive the existence of the element corresponding to the node, and the node naturally does not need to be buried.

Based on this, an exemplary embodiment of step S220 may include: and determining a first target node according to the node which is configured with the target parameter and the visibility attribute in the page node tree. Wherein the visibility attribute may be determined by a value of a parameter controlling visibility of the element.

Taking the parameter controlling the visibility of the element as visibility as an example, when the value of visibility is true, the token element is visible, that is, the element has a visibility attribute, and when the value of visibility is false, the token element is invisible, that is, the element has an invisible attribute.

In other words, if the value of the visibility parameter of a node is true, that is, the node is characterized by being configured with a visibility attribute, the node is characterized as being visible when the node is configured with the visibility attribute. If the value of the visibility parameter of a certain node is false, the node is characterized to be configured with the invisible attribute, and when the node is configured with the invisible attribute, the node is not characterized to be visible.

In general, only the corresponding element can be completely displayed or hidden by using the visibility parameter, and partial element content cannot be displayed. Based on this, an exemplary implementation of step S210 described above may include: and when the traversed node is configured with the invisible attribute, not traversing the child nodes of the node. Therefore, the buried point objects can be visible, and the accuracy of reporting the buried point information is improved.

In an exemplary scenario, such as the page shown in fig. 3, clicking on more controls 31 behind the song, the open float may be a separate window 32 with no parent-child relationship to the song page and the internal elements, but on data analysis it may be necessary to know from which song card in the song page each click within the float originated.

Based on this, in the process of generating the buried point object tree, in order to achieve the condition that multiple ends are consistent as much as possible and the business data requirements are met, in the disclosure, one node can be separated from the parent-child relationship in the page level of the node through logical mounting so as to establish a new parent-child relationship. For example, the floating layer object in fig. 3 is logically mounted under the singing sheet card or singing sheet object, that is, the floating layer object is used as a sub-level object of the singing sheet card or singing sheet object.

In another exemplary scenario, as shown in the page of fig. 4, for the buried event of each song list in the dashed box 41, each song card in the dashed box 42, the "more" control 43 of the recommended song list column, and the "play" control 44 of the song column, it may be necessary to know the module information to which it belongs, but when the front-end page of the client is developed, in order to reduce the UI hierarchy, there may not be a hierarchy of the whole module, such as the hierarchies corresponding to the dashed box 41 and the dashed box 42, and only the splicing illusion that the recommended song column and the list of the laterally scrolled song list of the song list below are displayed on the whole list.

In order to add an analyzable data level to a page parent-child level which does not exist in the interface level relationship of the page originally, the parent-child relationship of the data level to be analyzed in the buried object tree can be determined by adding a virtual node. As for the page in fig. 4, a layer of virtual nodes corresponding to the dashed line box 41 and the dashed line box 42 may be added, and the virtual nodes are mounted under a certain node in the page node tree according to the parent-child relationship that the virtual nodes need to bear.

In another exemplary scenario, in order to accurately report the embedded point information and perform subsequent data analysis, the parent-child relationship of a certain node in the interface hierarchical relationship may be different from that in reporting the embedded point information, and similarly, the node also needs to be logically mounted.

In summary, there are two cases where a logical mount is required; first, the node to be mounted does not originally exist in the node tree corresponding to the interface level of the page. For example, the node corresponding to the popup event does not have a hierarchical relationship with the currently displayed page, and is an independent window, that is, the popup node does not exist in the node tree corresponding to the interface hierarchy of the currently exposed page, and when the popup event occurs due to the trigger operation, the popup node can be automatically mounted below the root page node of the page exposed by the trigger operation according to the preset mounting node defined in the embedded point management platform, so as to determine the embedded point object tree. Secondly, a node to be mounted is originally a certain node in a page node tree corresponding to an interface level of a page, but the parent-child relationship of the node in the page node tree is not the parent-child relationship required when the embedded point information is reported, so that the parent-child relationship of the node in the embedded point object tree can be redefined on an embedded point management platform, and if the node is mounted below other nodes of the page, the preset mounting relationship corresponding to the node is determined, so that when the page node tree is traversed, if the traversed node has the preset mounting relationship, the node is not reserved firstly, but is added into the embedded point object tree again according to the preset mounting relationship after the traversal is completed.

Based on this, another exemplary embodiment of step S220 may include: determining a first target node according to the nodes which are configured with the target parameters and do not have a preset mounting relation in the page node tree; the preset mount relation is used for indicating the parent-child relation of the node in the buried point object tree.

For example, whether a node has a preset mounting relationship may be determined according to whether the node is configured with a parameter representing the preset mounting relationship.

In an exemplary embodiment, a page node tree may be traversed from a root node, and then a first target node for constructing the buried object tree may be determined according to a node in the page node tree that is configured with a buried object identifier, has a visibility attribute, and does not participate in a logical mount.

Next, in step S230, a buried object tree is generated based on the first target node.

In an exemplary embodiment, the specific implementation manner of step S230 may include: generating an initial buried object tree based on the parent-child relationship of each first target node in the page node tree; adjusting the initial buried point object tree according to a preset mount node associated with a first target node in the initial buried point object tree to generate the buried point object tree.

The preset mount node and a first target node in the buried point object tree have a first preset parent-child relationship, the preset mount node comprises one or more of a node for representing a preset event, a node which exists in the page node tree and has a first preset parent-child relationship with any one of the first target nodes, and a node which does not exist in the page node tree and has a first preset parent-child relationship with any one of the first target nodes, under the condition that the preset mount node exists in the page node tree, the first preset parent-child relationship is different from a second preset parent-child relationship, and the second preset parent-child relationship comprises the parent-child relationship of the preset mount node in the page node tree.

For example, a node used for characterizing a preset event may be understood as a node corresponding to a preset event that needs to be mounted, such as a node corresponding to a popup event. The node existing in the page node tree and having the first preset parent-child relationship with any one of the first target nodes may be understood as a node itself belonging to the page node tree, but the parent-child relationship is adjusted to the first preset parent-child relationship in the buried point object tree from the second preset parent-child relationship in the page node tree. The node having no first predetermined parent-child relationship with the page node tree and with any first target node may be understood as the newly added virtual node, such as the virtual node in fig. 5, which does not exist in the page node tree originally, but is needed in the buried point object tree, so that it may be added in the buried point object tree through the predetermined mount relationship.

The first target nodes are determined from the nodes in the page node tree, so that an initial embedded object tree can be generated according to the original parent-child relationship of each first target node in the page node tree, and then the initial embedded object tree is adjusted according to the preset mounting relationship to obtain the embedded object tree corresponding to the target display page.

If the preset mounting node can be added to the initial buried point object tree according to the preset mounting relationship, so as to generate a buried point object tree corresponding to the target display page.

FIG. 5 shows a schematic diagram of a logical mount process according to an embodiment of the present disclosure. As shown in fig. 5, the virtual nodes in fig. 5 represent an added node hierarchy, and as can be seen from the comparison of the left and right trees in fig. 5, the parent-child relationship between the session node and the virtual node is deleted in the buried object tree, and the session node is mounted under the root page node again. Where an "X" indicated at 51 in fig. 5 represents the deletion of the parent-child relationship between the virtual node and the session in the buried-point object tree.

By generating the buried point object tree based on the attribute information of the nodes in the page node tree, the consistent buried point capability facing the buried point object can be realized, the realization of the buried point scheme is irrelevant to a specific service frame and service logic, and the method is suitable for complex service scenes. Meanwhile, by the logic mounting and virtual node adding mode, accurate data support can be provided for subsequent data analysis, such as accuracy of attribution of a buried point can be guaranteed.

Fig. 6 shows a schematic flow chart of another method for generating a buried point object tree according to an embodiment of the present disclosure. Referring to fig. 6, the method may include steps S601 to S607.

In step S601, a node queue corresponding to the page node tree is traversed; in step S602, it is determined whether the queue is empty, and if not, the process goes to step S603, and if so, the process goes to step S607; in step S603, it is determined whether the traversed node is retained, and if the traversed node is required to be retained, the process goes to step S604, and if the traversed node is not required to be retained, the process goes to step S601; in step S604, it is determined whether the node has a parent node, if yes, go to step S605, otherwise go to step S606; in step S605, mount the traversed node under the parent node; in step S606, it is determined that the current node is a root node; in step S607, it is determined that the traversal is ended, and the logic mounting process is performed.

The step S603 of determining whether to keep the traversed node may include: and if the node is configured with the target parameters, has the visibility attribute and does not participate in the logic mounting, the node is included, otherwise, the node is not reserved. Meanwhile, under the condition that the traversed node is judged not to have the visibility attribute, the child node of the node is not traversed, and other nodes in the same level of the node are traversed based on a depth-first traversal mode.

Illustratively, the logical mount is automatically performed after traversing the page node tree, and the child nodes of the nodes are recursively processed during the logical mount.

In an alternative embodiment, an AOP (Aspect organized Programming) based on HOOK (which generally refers to intercepting some methods, such as creating a proxy object during program execution and then replacing the original object with the proxy object) can be implemented by the system update opportunity of the operating system where the client is located to implement automatic generation of the update and detection frequency of the buried object tree in the present disclosure and alignment of the operating system rhythm. And the HOOK (AOP) called back by various users in the system framework is utilized to realize the automatic triggering and embedding of the related object triggering event.

Taking android as an example, the android AOP occasion may include dialog lifecycle, sliding AOP, fragment (Fragment is a newly added concept of android3.0, and chinese means "Fragment") lifecycle, activity lifecycle, click AOP, and so on. For the sliding AOP, a sliding event may be monitored by monitoring the sliding AOP, then the sliding state is updated according to the sliding event, whether to stop sliding is determined, and if sliding is stopped, a buried object tree is generated. Whether to stop slipping can be determined by list multiplexing AOPs.

Taking the IOS (mobile operating system developed by apple as an example) end, the IOS end can take Hook by the methods of Method Swizzle and NSProxy. Specific Hook occasions may include: click events, list slide events, view controller (controller of View, i.e. a generic page, which manages the life cycle of a page), app (application) level life cycle, uialert controller (user interface prompt controller) and uialert action (user interface prompt box button), etc.

Based on the AOP opportunity, one or more of an element click event, a page exposure event, a list sliding event and the like which occur at a client can be responded to generate a buried object tree, and then the detection of the exposure state of the buried object can be realized by comparing the difference of the tree structures of adjacent buried object trees, so that the automatic buried of the exposure event and the reverse exposure event and the automatic collection and report of buried point information can be realized. Wherein a back exposure event may be understood as a change of the buried point object from a visible state to an invisible state.

Referring to fig. 1 again, in step S130, a buried point object to be reported is determined based on the generated adjacent buried point object tree, so as to report buried point information according to the buried point object to be reported.

For example, fig. 7 is a flowchart illustrating a method for determining a to-be-reported buried object according to an embodiment of the disclosure. Referring to fig. 7, the method may include steps S710 to S720.

In step S710, visible nodes in the first and second buried point object trees are determined.

The first buried object tree is a buried object tree generated earlier in the adjacent buried object trees, the second buried object tree is a buried object tree generated later in the adjacent buried object trees, and the buried object indicated by the visible node is not completely blocked in the graphical user interface of the client.

In other words, a visible node may be understood as a node in the buried object tree that is not completely occluded by other nodes. If some or a certain element in the page is blocked by other elements or sub-pages, even if the element has a visibility attribute, the element is invisible to the perception of the user, so in order to improve the accuracy of reporting the buried point information, when exposure detection of the buried point object is performed, whether the buried point object is really visible in the view needs to be judged, that is, whether the buried point object is not completely blocked.

When judging whether the buried object is really visible, the concept of the real visible area of the object is involved. The bounds of the area where the object is actually displayed (view boundaries, which are used to determine the position and size of the display of the content of the view within the view) can be reached by the system framework API through the layout properties of the object, but the actual visible area of an element may be larger than the area actually displayed and may be smaller than the area actually displayed.

As shown in fig. 8, a schematic diagram of the real visible area of the object is presented. Here, the dashed box 81 can be understood as the frame of the element A1 or the page A2 (frame of the view, for locating the position and size of the view within its parent view, which contains two structures representing the origin and size of the view, the origin of the view can be understood as the origin of the view within its parent view, and the size of the view can be understood as the view rectangle size), taking A1 as an example, the frame of A1 has its margin around Top (Top), bottom (Bottom), left (Left), right (Right), and the rest is the true visible area 82 of a. When the values of Top, bottom, left, and Right are negative numbers, it indicates that the real visible region exceeds the frame. In the present disclosure, the actual frame of View, i.e., the display rectangle of the View, can be modified through the API to support situations such as semi-transparent actual back-viewing. Meanwhile, in exposure detection of the buried point object, the shielding of the buried point object is judged on the basis of the real visible area and the tree structure of the node.

Taking FIG. 9 as an example, the P _ A page is covered by the P _ B float sub-page, the P _ A page has elements e _1, e _2 and e _3, and the P _Bfloat sub-page includes elements e _5 and e _6. Occlusion is typically where a child page occludes an element within a parent page, such as the child page P _ B in fig. 9 occluding an element in the parent page P _ a, and if there is no parent page, the occlusion is a top-level element node. The real visible area of the sub-page P _ B needs to be subtracted by Top, so the sub-page P _ B will block two elements e _2 and e _3, but not e _1. The elements visible in FIG. 9 are e _1, e _5, and e _6, and the pages visible are P _ A and P _ B.

The node tree of the page in fig. 9 is shown in fig. 10. The following conclusions can be drawn in conjunction with fig. 9 and 10: a page node may block other child nodes under its parent node (the parent node may be an element or a page) that are added earlier than the page node, i.e., a node at the same level as and to the left of a page node in the buried object tree may be blocked by the page node.

Therefore, in order to improve the accuracy of reporting the buried point information, when the buried point information is reported according to the difference between the previous buried point object tree and the next buried point object tree, it is necessary to determine whether the buried point object in the buried point object tree is not completely blocked, that is, whether the buried point object can be really seen by the user in the graphical user interface.

Based on this, it is necessary to determine visible nodes in the first buried point object tree and the second buried point object tree, respectively. The visible node can be understood as a node corresponding to the buried point object which is not completely shielded in the buried point object tree and can be really seen by a user.

Illustratively, fig. 11 shows a flowchart of a method for determining visible nodes according to an embodiment of the present disclosure. Referring to fig. 11, the method may include steps S1110 to S1140. Wherein:

in step S1110, the buried object tree is traversed, and when the currently traversed node is the second target node, the parent node of the second target node is obtained.

As shown in FIG. 9, a node of a page type may block its left-hand node and its children nodes. In one exemplary embodiment, the second target node is a page type node. In other words, it is necessary to determine whether the page type node in the buried object tree completely occludes other nodes.

In an exemplary embodiment, the nodes in the buried object tree include nodes of a page type and/or nodes of an element type. Taking the buried point object tree in fig. 12 as an example, P1, P2, P3, and P4 represent nodes of a page type, and e1, e2, e3, e4, e5, e6, and e7 represent nodes of an element type. P1 is the root node in the buried object tree, and P2 has no node on the left side, so that only the shielding situation of the P3 node and the P4 node on other nodes is considered. P3 may occlude e1, e2, e3, e4, and P4 may occlude P2, P3, e1, e2, e3, e4, e6. That is, when the parent node of the page node is the page type node in the occlusion determination, the page type node may occlude its node on the left side of the same hierarchy and its child nodes. But in the case where the parent of a page node is an element type node, it may also obscure nodes to the left of the parent's sibling level.

In other words, according to the type of the parent node of the second target node, another node that may be occluded by the second target node, that is, a node to be processed, may be determined, so as to perform subsequent occlusion determination processing on the node to be processed.

Next, in step S1120, a node to be processed corresponding to the second target node is determined in the buried object tree according to the type of the parent node of the second target node.

For example, when the type of the parent node of the second target node is a page type, the node to be processed corresponding to the second target node may be determined in the following manner: and determining a node to be processed corresponding to the second target node according to the node and the sub-nodes thereof which are positioned in the same level with the second target node and positioned on the left side of the second target node in the buried point object tree.

Since the buried object tree is generated based on the page node tree by depth-first traversal when the buried object tree is built, the node located to the left of the second destination node may be understood as a node added earlier in time than the second destination node in the buried object tree, or may be understood as a node located before the second destination node in the node array corresponding to the buried object tree. Being at the same level as the second target node may be understood as a node that is in a sibling relationship with the second target node.

For example, in a case that the parent node of the second target node is a node of an element type, a method of determining a node to be processed corresponding to the second target node may be as shown in fig. 13. As in fig. 13, the method may include steps S1310 to S1340.

In step S1310, a first node to be processed is determined according to a node and its child nodes that are in the same level as the second target node and located on the left side of the second target node in the buried point object tree; in step S1320, a second node to be processed is determined according to a node in the buried point object tree, which is at the same level as the parent node of the second target node and located on the left side of the parent node of the second target node; in step S1330, the step of searching for the parent node of the second target node is repeatedly performed, and when the found current parent node is the third target node of the element type, the third node to be processed is determined according to the node which is in the same level as the third target node in the buried node object tree and is located on the left side of the third target node, and the search is stopped when the found current parent node is the page type or the parent node is not found currently; in step S1340, a node to be processed corresponding to the second target node is determined according to the first node to be processed, the second node to be processed, and the third node to be processed.

For example, as previously described, where the parent node of a page node is a node of an element type, in addition to possibly blocking nodes and their children on the left side of the same level of the page node, the nodes on the left side of the same level of the parent node of the page node may also be blocked. Likewise, in the case where the parent node of the parent node is still an element node, the node on the left side of the parent node in the same hierarchy may also be occluded. Therefore, the step of searching for the parent node of the second target node may be repeatedly performed until the parent node of the page type is found, and the search is stopped to determine the node to be processed which may be blocked by the second target node. And if the parent node of the page type is not found when the found parent node is the root node, stopping searching.

Next, in step S1130, invisible nodes among the nodes to be processed are determined based on the first display area and the second display area.

In an exemplary embodiment, the first display area is a display area of a buried point object indicated by a traversed node of the page type in the graphical user interface, and the second display area is a display area of a current node to be processed in the graphical user interface.

For example, one specific implementation of step S1130 may include: and when the first display area and the second display area are determined to have the overlapped part and the display size of the overlapped part is equal to that of the second display area, determining the node to be processed corresponding to the second display area as the invisible node.

For example, for each node to be processed corresponding to the currently traversed second target node, whether the node to be processed is a visible node may be determined by determining whether the two display regions of the buried point object indicated by the node to be processed in the graphical user interface are completely occluded by the first display region of the buried point object indicated by the currently traversed second target node in the graphical user interface. If the node to be processed is completely occluded, the node to be processed is an invisible node, and if the node to be processed is not completely occluded, the node to be processed is a visible node. For example, if the first display area and the second display area have an overlapping portion, it is continuously determined whether the size of the overlapping area is equal to the size of the display area corresponding to the node to be processed, and if so, it is determined that the node to be processed is completely blocked by the second target node, that is, the node to be processed is an invisible node.

Next, in step S1140, visible nodes in the buried object tree are determined from invisible nodes in the buried object tree.

For example, nodes of the buried object tree other than the determined invisible node are visible nodes of the buried object tree.

It should be noted that, when determining whether the node is completely occluded, the processes from step S1110 to step S1130 are repeatedly performed on the traversed nodes of each page type to determine the invisible node set corresponding to the node of each page type, and finally, the invisible node sets of the nodes of each page type are combined to determine the invisible nodes in the buried point object tree. In other words, when determining the visible node, it is only necessary to see whether the current occlusion is determined to be visible without considering a situation that a plurality of page nodes occlude an element at the same time, and finally, the determination results of each page node are summarized to determine all invisible nodes in the buried node object tree, so as to determine the visible node in the buried node object tree based on nodes other than all invisible nodes.

By judging the shielding condition between the objects, the visible nodes which can be really seen by the user in the currently exposed page can be determined, and then the buried point objects to be reported are determined based on the visible nodes, so that the accuracy of buried point reporting is improved.

Next, with reference to fig. 7, in step S720, a buried point object to be reported is determined according to the visible nodes in the first buried point object tree and the second buried point object tree.

For example, in a specific implementation manner of step S720, for any of the visible nodes, if the visible node appears in the first buried point object tree and does not appear in the second buried point object tree, it is determined that the buried point object indicated by the visible node is the first buried point object to be reported; and for any visible node, if the visible node appears in the second buried point object tree and does not appear in the first buried point object tree, determining that the buried point object indicated by the visible node is the second buried point object to be reported. The first buried point object to be reported can be understood as a reverse exposure buried point object, and the second buried point object to be reported is an exposure buried point object.

For example, another specific implementation of step S720 can be found in fig. 14. Fig. 14 is a flowchart illustrating a method for determining a to-be-reported buried point object according to a visible node according to an embodiment of the present disclosure. As shown in fig. 14, the method may include steps S1410 through S1420. Wherein:

in step S1410, for any visible node, a first number of occurrences of the visible node in the first buried object tree and a second number of occurrences in the second buried object tree, respectively, are determined.

For example, a first node array corresponding to a node in a first buried point logarithm tree and a second node array corresponding to a node in a second buried point object tree may be obtained. Then, the two arrays are traversed respectively, and the occurrence frequency of each node in the first node array and the occurrence frequency of the node in the second node array are recorded. And matching the nodes in the first node array with the nodes in the second node array according to the node identifiers, so that the first occurrence frequency of each visible node in the first buried object tree and the second occurrence frequency of each visible node in the second buried object tree can be determined.

Next, in step S1420, the buried point object to be reported is determined according to the first occurrence number and the second occurrence number of each visible node.

Illustratively, one specific implementation of step S1420 may include: when the first occurrence number of the visible node is greater than 0 and the second occurrence number of the visible node is equal to 0, determining that the buried point object indicated by the visible node is a first buried point object to be reported; and when the first occurrence number is equal to 0 and the second occurrence number is greater than 0, determining the buried point object indicated by the visible node as a second to-be-buried point object.

For example, if the first number of occurrences of a node in the first buried object tree is greater than 0 but the second number of occurrences of the node in the second buried object tree is equal to 0, it indicates that the node has occurred in the first buried object tree, but has not occurred in the second buried object tree, then the node is the end-of-exposure node, i.e., the back-exposure node, which indicates that the buried object is the first to-be-reported buried object. If the first number of occurrences of a node in the first buried object tree is equal to 0 and the second number of occurrences of the node in the second buried object tree is greater than 0, it means that the node has not occurred in the first buried object tree but occurred in the second buried object tree, then the node is the node that started exposure, and the buried object indicated by the node is the second buried object to be reported.

Next, a specific process of determining a buried point object to be reported from the neighboring buried point object tree will be further described by taking fig. 15 and fig. 16 as an example. Figure 15 illustrates a schematic diagram showing a neighborhood buried object tree according to an embodiment of the present disclosure. In fig. 15, the buried point object tree T1 is a buried point object tree generated earlier in the order of adjacent buried point object trees, i.e., a buried point object tree in the front, and the buried point object tree T2 is a buried point object tree generated later in the order of adjacent buried point object trees, i.e., a buried point object tree in the rear. When determining the buried point object to be reported, node arrays corresponding to the nodes in T1 and T2 may be obtained first, as shown in fig. 16.

Then, the two node arrays are traversed respectively, and the occurrence number of each node in the node arrays is recorded. For example, the record data of the node 1 comprises id:1, oid count:1 and newcount:1; the record data of the node 2 comprises id:2, oid: 1 and newcount:1; the record data of the node 3 includes id:3, oid: 1, newcount:0, and the record forms of other nodes are the same, which is not described herein again. Where oid count represents the number of occurrences in the first buried object tree and newcount represents the number of occurrences in the second buried object tree. And then, according to the value of the oid count and the value of the newcount of each node, determining a first buried object to be reported after exposure is finished and a second buried object tree to be exposed. That is, when the oid count is greater than 0 and the newcount is equal to 0, the node can be determined as the node to be exposed, and when the oid count is equal to 0 and the newcount is greater than 0, the node can be determined as the node to be exposed, and the other nodes are nodes that do not change.

As shown in fig. 15, the exposure of the

nodes

4, 6, 3, 7, 8, 11 in T1 ends and the exposure of the

nodes

20, 21, 22, 23 in T2 starts.

For example, when events such as system update and click occur, a workflow for reporting a buried object is relatively long, and if an execution process of a related workflow is placed on a main thread, a problem of pause in UI rendering may be caused. Therefore, in this disclosure, a buried-point SDK (Software Development Kit) worker thread is introduced to share the workload of the primary thread. Based on this, fig. 17 shows a schematic workflow diagram of a method for performing reporting of the embedded point information according to an embodiment of the present disclosure.

As can be seen from fig. 17, in the present disclosure, in order to reduce the influence of frequent calculation on the system operation performance during reporting of the embedded point information, the process of generating the embedded point object tree vTree may be processed by the main thread, and meanwhile, the preparation data of the node needs to be obtained in the main thread. Specifically, the method can include setting parameters of the buried object dimension and calculating VisbleRect (display area, the result of which is relative to the value of the parent node) of the node dimension. The display area for calculating the node dimension may be a display area only corresponding to the parent node, or may be a display area calculated by recursion upward of the buried point object tree. The generated buried object tree may be stored in a buried object tree Task Queue, such as the vTree Task Queue shown in fig. 17. And then sequentially acquiring the buried object trees from the buried object tree task queue through the sub-threads according to the storage sequence, and carrying out shielding calculation on nodes in the buried object trees to generate a visible node array corresponding to the buried object trees. And the sub-thread can also determine the exposed and/or back-exposed buried point object according to the difference between the visible node arrays corresponding to the adjacent buried point object trees and then output the exposed and/or back-exposed buried point object.

In order to further reduce the influence of the reporting process of the buried point information on the system performance and avoid the occurrence of system jamming, the method also limits the work of triggering the updating of the buried point object tree and detecting the difference between adjacent buried point object trees by a plurality of time operations such as CPU (Central Processing Unit) idle judgment, local updating construction limitation, main thread circulation remaining time limitation, list sliding callback event combination and the like, so as to effectively reduce the working times and workload of the whole working thread and achieve the effect of avoiding system jamming.

Based on this, a specific embodiment of step S120 can be referred to as shown in fig. 18. Fig. 18 is a flowchart illustrating a further method for generating a buried point object tree according to an embodiment of the present disclosure. Referring to fig. 18, the method may include steps S1810 to S1820. Wherein:

in step S1810, the first preset storage container is updated according to the trigger operation and the root page of the target display page exposed by the trigger operation.

Wherein the first preset storage container may include a queue. For example, when a trigger operation is detected in the client, a message corresponding to the trigger operation may be generated according to the trigger operation. Then, according to the sequence of the trigger operations, storing the message corresponding to the trigger operation and the root page identifier of the target display page exposed by the trigger operation in a first preset storage container, for example, in a preset page update queue, so as to update the first preset storage container. And the message corresponding to the trigger operation is used for indicating that the front-end page of the client is changed.

Next, in step S1820, for each root page updated in the first predetermined storage container, a buried object tree corresponding to the root page is generated according to the attribute information of the nodes in the page node tree corresponding to the root page, based on a predetermined period.

For example, according to a preset period, for each root page identifier updated in the first preset storage container in the current period, the page node tree corresponding to the root page identifier is obtained, so that the buried point object tree corresponding to the root page is generated according to the attribute information of the page node tree. The method for generating the buried object tree according to the attribute information of the node in the page node tree has been described in the foregoing specific embodiments, and is not described herein again. The preset period may be configured by self-definition according to a requirement or experience or a cycle duration of the main thread, which is not particularly limited in this exemplary embodiment.

For example, a specific implementation of step S1820 may be described with reference to fig. 19. Fig. 19 is a flowchart illustrating a method for generating a buried point object tree corresponding to a root page according to an embodiment of the present disclosure. Referring to fig. 19, the method may include steps S1910 to S1930.

In step S1910, a time to be processed is determined based on the preset period.

Taking the preset period of 1 minute as an example, every other minute corresponds to a time to be processed. Therefore, the time to be processed can be determined according to the preset period. For example, the previous time to be processed is 9: 50, the next time to be processed is 9: 51, and so on.

Next, in step S1920, when any time to be processed arrives, if the remaining time of the operating cycle of the main thread of the terminal device where the client is located is greater than or equal to the first preset value, it is determined that the time to be processed is the target time.

In this disclosure, a client may be understood to be any application client. For example, when any one to-be-processed time arrives, whether the remaining time length of the operating cycle of the main line of the terminal device where the application client is located is greater than or equal to a first preset value or not may be judged, if so, the to-be-processed time is determined to be the target time, otherwise, the next to-be-processed time arrives, and then, whether the remaining time length of the main thread cycle of the terminal device where the application client is located is greater than or equal to the first preset value or not may be judged, if so, the to-be-processed time is determined to be the target time, otherwise, the next to-be-processed time arrives.

The Run Loop of the main thread can be understood as Run Loop of the main thread, and the Run Loop is a mechanism for enabling the thread to process events at any time but not exit. Run Loop is essentially an object, which can keep the continuous operation of a program and process various events in the program, and when nothing is processed by Run Loop, a thread enters a sleep state, so that the CPU resource can be saved and the program performance can be improved.

In step S1930, at the current target time, for each root page updated in the first preset storage container from the previous target time to the current target time, based on the update sequence, according to the attribute information of the node in the page node tree of the root page, a buried point object tree corresponding to the root page is generated.

For example, a plurality of target moments can be determined according to the moments to be processed, then, for each current target moment, a root page identifier stored in a first preset storage container from a previous target moment to the current target moment can be sequentially obtained according to a storage sequence, and then, a page node tree corresponding to the obtained root page identifier is processed to obtain a buried point object tree corresponding to each page node tree.

In other words, in the present disclosure, whether to generate the embedded point object tree is determined according to the remaining duration of the running loop of the main thread, and when the remaining duration of the running loop of the main thread is sufficient, such as when the remaining duration is greater than or equal to the first preset value, the embedded point object tree is generated again, so that the influence of the reporting process of the embedded point information on the system running is avoided, and the possibility of the system hang-up situation is reduced.

Illustratively, where the trigger operation for the client includes a slide operation, the buried object tree may be generated according to the method shown in FIG. 20. Fig. 20 is a flow chart illustrating another method for generating a buried point object tree according to an embodiment of the present disclosure. Referring to fig. 20, the method may include steps S2010 to S2030. Wherein:

in step S2010, a sliding message of the sliding operation is collected according to a first preset time interval, and a second preset storage container is updated according to the collected sliding message and the child node identifier corresponding to the list to which the sliding operation is directed.

For example, if a list sliding event exists in a certain page, it is characterized that exposure of a new page does not occur, so in order to save computing resources of the system, a buried point object tree corresponding to a root page of a page where a sliding list is located may be locally updated only according to a sliding operation, and a buried point object tree generated by the sliding operation may be obtained.

When the list is swiped, a list swipe message is generated at regular intervals to indicate that the list is swiped, e.g., a message may be generated at every 2ms to indicate that the list is currently being swiped. In order to achieve the purpose of limiting the flow, the list sliding message generated in the list sliding process may be collected at a first preset time interval to obtain the list sliding condition. Wherein the first preset time interval is greater than the fixed time interval for generating the list sliding message. If the fixed time interval is 2ms, the first preset time interval may be 1s, so as to implement the merging process for the same list sliding event.

For example, the second preset storage container may be updated according to the collected sliding message and the child node identifier corresponding to the list to which the sliding operation is directed. For example, when a sliding message is collected, the child node identifier corresponding to the sliding list indicated by the sliding message is acquired, and then the sliding message and the child node identifier corresponding to the sliding message are stored in a second preset storage container. For example, when a sliding message is collected, a child node identifier corresponding to the sliding list indicated by the sliding message may be acquired, the child node identifier is matched with an existing child node identifier in the queue, and if the matching is successful, the existing child node identifier in the queue is replaced by the child node identifier, so that the second preset storage container is updated. Wherein, the second preset storage container may also be a queue.

In other words, the first preset storage container stores the variation information corresponding to the exposure of the new page, and the second preset storage container stores the list sliding the corresponding variation information. That is, the case of exposure of a new page can be known based on the first preset storage container, and the case of list sliding can be known based on the second preset storage container.

Next, in step S2020, when the first preset storage container is not updated and the second preset storage container is updated, the updated child node identifier in the second preset storage container is traversed from the child node identifier to the page node tree where the child node identifier is located based on the update sequence, so as to generate the buried point object tree.

For example, when the target time arrives, if the first preset storage container is not updated and the second preset storage container is updated, it indicates that no new page exposure occurs in the time period from the last target time to the current target time, and only a list sliding event occurs in the current page, so that the previous embedded point object tree may be incrementally updated based on the page node tree to generate the embedded point object tree corresponding to the list sliding event. For example, the page node tree of the current page is traversed from the child node corresponding to the list, and a new buried-point object tree is generated incrementally based on the buried-point object tree generated during the exposure of the current page.

If the second preset storage container stores the child node identifiers of the sliding list corresponding to each acquired sliding message, in other words, for the sliding event of the same list, the second preset storage container stores multiple times of update information, the same child node identifiers can be merged, that is, for the same child node identifiers, only one traversal process is executed.

In step S2030, when the first preset storage container is updated, for each root page updated in the first preset storage container, traversing the page node tree corresponding to the root page from the node corresponding to the root page based on the update sequence to generate the buried point object tree.

For example, when the target time comes, if the first preset storage container is updated, it indicates that the exposure of the new page occurs, so no matter whether the second preset storage container is updated, a new embedded object tree is generated in full according to the page node tree corresponding to the newly exposed page, that is, the page node tree is traversed from the root node of the newly exposed page, and the new embedded object tree is generated.

According to the method and the device, the current limitation of the buried point information reporting process is realized, the influence of the buried point information reporting on the system performance is reduced, and the occurrence of system jamming is avoided or reduced by the modes of judging the residual time of the running cycle of the main thread, realizing a local updating buried point object tree mechanism based on the second preset storage container, combining the sliding events of the sliding list and the like.

Next, the process of limiting the reporting of the burial point information in the present disclosure will be further described with reference to fig. 21. Fig. 21 is a schematic diagram illustrating a process of performing work current limitation on reporting of embedded point information according to an embodiment of the present disclosure. As shown in fig. 21, UI change 1, UI change 2, and UI change 3 in fig. 21 represent 3 new page exposure events, and list scroll 1 and list scroll 2 represent 2 list scroll events. For example, the new page exposure events may be sequentially stored in the UI change queue according to the occurrence order of the events, and the list scroll events may be sequentially stored in the list scroll queue according to the occurrence order of the events. And then waiting for the arrival of the time to be processed according to a preset period, judging whether the CPU is idle when the time to be processed arrives, if so, continuously judging whether the residual time of the running loop RunLoop of the main thread is enough, if not, exceeding a certain preset value, if so, shunting the rolling event and the page exposure event, acquiring an updated exposure page from the previous processing time to the current processing time from the UI change queue for the page exposure event, then generating a corresponding buried object tree according to the preset mode full quantity, acquiring an updated list rolling event from the previous processing time to the current processing time from the list rolling queue for the list rolling event, and generating a new buried object tree based on the common mode increment.

It should be noted that both the UI change queue and the list scroll queue may be consumption type queues, that is, messages in the queues are deleted from the queues after being consumed. Therefore, when each target time arrives, the messages currently stored in the queue are the updated contents from the last target time to the current target time, and the messages currently stored in the queue can be directly and sequentially processed to generate the buried object tree.

After the buried point object tree is generated, the buried point object to be reported can be determined according to the difference of adjacent buried point object trees, and then the buried point information is reported based on the buried point object to be reported.

Fig. 22 is a flowchart illustrating a method for reporting buried point information according to a buried point object to be reported according to an embodiment of the present disclosure. Referring to fig. 22, the method may include steps S2210 to S2230. Wherein:

in step S2210, a buried point object identifier chain from the node corresponding to the buried point object to be reported to the root node in the buried point object tree is determined based on the parent-child relationship of the node corresponding to the buried point object to be reported in the buried point object tree and the buried point object identifier configured for the buried point object to be reported in advance.

For example, if the buried object identifier of the buried object to be reported is oid1, the buried object identifier of the parent node is oid2, the buried object identifier of the parent node is oid2, the parent node of the parent node is the root node, and the buried object identifier of the root node is oid3, the buried object identifier chain determined according to the buried object identifier to be reported 1 is _ oid1| _ oid2| _ oid3.

In step S2220, the location attribute information of the buried point object to be reported is added to the buried point object identifier chain, so as to obtain the pit bit information of the buried point object to be reported.

Continuing with the example of the buried point object to be reported oid1, as for the parent node, the parent node has the position attribute information pos2, and the pit bit information of the buried point object to be reported is _ oid1| _ oid2: pos2| _ oid3|. And the position attribute information is added, so that the accuracy of pit bit information description can be ensured. For example, based on the idea of component multiplexing, for different list units of the sliding list, corresponding buried point object identifiers are the same, but different list units have different location information, such as a first list unit, a second list unit, and the like, so that location attribute information is added, pit positions of the buried point object to be reported can be described more accurately, and the accuracy of reporting the buried point information is improved.

In step S2230, the buried point information of the buried point object to be reported is reported according to the pit bit information of the buried point object to be reported.

For example, the reporting parameter of the buried point information of the buried point object included in the pit bit information may be used to report the buried point information to be reported. And reporting the embedded point information according to the pit bit information and the value of the embedded point information reporting parameter of the embedded point object to be reported.

The embedded point information reporting method can realize automatic embedded point and automatic reporting of embedded point information, can realize consistency of embedded points of clients of different versions or clients of different operating systems (such as Android/Ios/pc/mac/H5/ReactNative/Flutter/CEF/Electron and the like), and can adapt to use of various complex service scenes, improve the efficiency of embedded points and the efficiency of embedded point information reporting, and reduce maintenance cost of embedded points. Meanwhile, the accuracy of reporting the buried point information is ensured through modes such as shielding judgment and the like. Furthermore, the influence of reporting of the embedded point information on the interaction and rendering of the front-end UI is reduced by limiting the reporting process of the embedded point information.

Exemplary devices

The exemplary embodiment of the present disclosure further provides a reporting device of the embedded point information. Referring to fig. 23, the reporting apparatus 2300 for the burial point information may include:

a page node tree determination module 2310 configured to determine, in response to a trigger operation for a client, a page node tree of a target display page exposed by the trigger operation;

a buried point object tree generating module 2320 configured to generate a buried point object tree according to the attribute information of the nodes in the page node tree;

the buried point information reporting module 2330 is configured to determine a buried point object to be reported based on the generated adjacent buried point object tree, and to report the buried point information according to the buried point object to be reported.

In an optional implementation, the page node tree determining module 2310 is specifically configured to: and determining a page node tree of the target display page exposed by the trigger operation according to the interface hierarchical relationship of the target display page exposed by the trigger operation.

In an alternative embodiment, the buried point object tree generating module 2320 is specifically configured to: generating a buried point object tree according to whether the target parameters are configured in the nodes in the page node tree or not; the target parameter is used for indicating that the node is a buried point object.

In an optional implementation manner, the determining a first target node according to the node configured with the target parameter in the page node tree includes: and determining a first target node according to the nodes which are configured with the target parameters and visibility attributes in the page node tree.

In an optional implementation manner, determining a first target node according to a node in the target node tree, where the target parameter is configured, includes: determining a first target node according to the node which is configured with the target parameter and does not have a preset mounting relation in the page node tree; the preset mounting relation is used for indicating the parent-child relation of the node in the buried point object tree.

In an alternative embodiment, the generating a buried object tree based on the first target node includes: generating an initial buried point object tree based on the parent-child relationship of each first target node in the page node tree; adjusting the initial buried point object tree according to a preset mount node associated with a first target node in the initial buried point object tree to generate the buried point object tree; the preset mount node and a first target node in the buried point object tree have a first preset parent-child relationship, the preset mount node comprises one or more of a node for representing a preset event, a node which exists in the page node tree and has a first preset parent-child relationship with any one of the first target nodes, and a node which does not exist in the page node tree and has a first preset parent-child relationship with any one of the first target nodes, when the preset mount node exists in the page node tree, the first preset parent-child relationship is different from a second preset parent-child relationship, and the second preset parent-child relationship comprises the parent-child relationship of the preset mount node in the page node tree.

In an optional implementation manner, the burial point information reporting module 2330 may be specifically configured to: determining visible nodes in the first buried point object tree and the second buried point object tree; determining a buried point object to be reported according to the visible node; the first buried object tree is a buried object tree generated earlier in the adjacent buried object trees, the second buried object tree is a buried object tree generated later in the adjacent buried object trees, and the buried object indicated by the visible node is not completely blocked in the graphical user interface.

In an optional implementation manner, the determining, according to the visible node, a buried point object to be reported includes: determining, for any of the visible nodes, a first number of occurrences of the visible node in the first buried object tree and a second number of occurrences in the second buried object tree, respectively; and determining a buried point object to be reported according to the first occurrence frequency and the second occurrence frequency of each visible node.

In an optional implementation manner, the determining, according to the first occurrence number and the second occurrence number of each visible node, a buried point object to be reported includes: when the first occurrence number is greater than 0 and the second occurrence number is equal to 0, determining that the buried point object indicated by the visible node is a first buried point object to be reported; and when the first occurrence number is equal to 0 and the second occurrence number is greater than 0, determining that the buried point object indicated by the visible node is a second to-be-buried point object.

In an alternative embodiment, the visible node is determined by: traversing a buried object tree, and acquiring a father node of a second target node when a currently traversed node is the second target node, wherein the second target node is a page type node; determining a node to be processed corresponding to the second target node in the buried object tree according to the type of the father node; determining invisible nodes in the nodes to be processed based on the first display area and the second display area; determining visible nodes in the buried point object tree according to invisible nodes in the buried point object tree; the first display area is a display area of the buried point object indicated by the traversed node of the page type in the graphical user interface, and the second display area is a display area of the current node to be processed in the graphical user interface.

In an optional implementation manner, the determining, according to the type of the parent node, a node to be processed corresponding to the second target node in the buried object tree includes: when the type of the father node is a page type, determining a node to be processed corresponding to the second target node by the following method: determining a node to be processed corresponding to the second target node according to the node which is positioned in the same level with the second target node in the buried point object tree and positioned on the left side of the second target node and the sub-nodes thereof; when the type of the father node is an element type, determining a node to be processed corresponding to the second target node by the following method: determining a first node to be processed according to a node which is positioned in the same level as the second target node in the buried point object tree and positioned on the left side of the second target node and child nodes thereof; determining a second node to be processed according to a node which is positioned in the same level with the father node and on the left side of the father node in the buried point object tree; repeatedly executing the step of searching the father node of the father node, when the found current father node is a third target node of an element type, determining a third node to be processed according to a node which is in the same level with the third target node in the embedded point object tree and is positioned on the left side of the third target node, and stopping searching when the found current father node is of a page type or the father node is not found currently; and determining a node to be processed corresponding to the second target node according to the first node to be processed, the second node to be processed and the third node to be processed.

In an optional implementation manner, the determining, based on the first display area and the second display area, an invisible node in the nodes to be processed includes: when it is determined that the first display area and the second display area have an overlapping portion, and the display size of the overlapping portion is equal to the display size of the second display area, determining that the node to be processed corresponding to the second display area is an invisible node.

In an optional implementation manner, the buried point information reporting module 2330 is further specifically configured to: determining a buried point object identification chain from the node corresponding to the buried point object to be reported to a root node in the buried point object tree based on the parent-child relationship of the node corresponding to the buried point object to be reported in the buried point object tree and a buried point object identification configured for the buried point object to be reported in advance; adding the position attribute information of the buried point object to be reported to the buried point object identification chain to obtain pit bit information of the buried point object to be reported; and reporting the buried point information of the buried point object to be reported according to the pit bit information of the buried point object to be reported.

In an alternative embodiment, the buried object tree generating module 2320 may be specifically configured to: updating a first preset storage container according to the trigger operation and the root page of the target display page exposed by the trigger operation; and generating a buried object tree corresponding to the root page according to the attribute information of the nodes in the page node tree corresponding to the root page aiming at each updated root page in a first preset storage container based on a preset period.

In an optional implementation manner, the generating, for each root page updated in the first preset storage container based on the preset period, a buried point object tree corresponding to the root page according to attribute information of a node in a page node tree corresponding to the root page includes: determining a time to be processed based on the preset period; when any one to-be-processed time arrives, if the residual time of the running cycle of the main thread of the terminal equipment where the client is located is greater than or equal to a first preset value, determining that the to-be-processed time is a target time; and at the current target moment, aiming at each root page updated in the first preset storage container from the last target moment to the current target moment, and generating a buried object tree corresponding to the root page according to the attribute information of nodes in a page node tree of the root page based on an updating sequence.

In an alternative embodiment, when the trigger operation comprises a slide operation, the method further comprises: collecting sliding messages of the sliding operation according to a first preset time interval, and updating a second preset storage container according to the collected sliding messages and child node identifications corresponding to the list to which the sliding operation aims; when the first preset storage container is not updated and the second preset storage container is updated, traversing a page node tree where the child node identifiers are located from the child node identifiers on the basis of an updating sequence aiming at the child node identifiers updated in the first preset storage container so as to generate a buried point object tree; when the first preset storage container is updated, for each updated root page in the first preset storage container, traversing a page node tree corresponding to the root page from a node corresponding to the root page based on an updating sequence to generate a buried point object tree.

In addition, other specific details of the embodiments of the present disclosure have been described in detail in the embodiments of the invention of the above method, and are not described herein again.

Exemplary storage Medium

Storage media of exemplary embodiments of the present disclosure are explained below.

In the present exemplary embodiment, the above-described method may be implemented by a program product, such as a portable compact disc read only memory (CD-ROM) and including program code, and may be executed on a device, such as a personal computer. However, the program product of the present disclosure is not so limited, and in this document, a readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.

The program product may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium include: an electrical connection having one or more wires, a portable diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

A computer readable signal medium may include a propagated data signal with readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A readable signal medium may also be any readable medium that is not a readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

Program code embodied on a readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RE, etc., or any suitable combination of the foregoing.

Program code for carrying out operations for aspects of the present disclosure may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user computing device, partly on a remote computing device, or entirely on the remote computing device or server. In the case of a remote computing device, the remote computing device may be connected to the user computing device through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computing device (e.g., through the internet using an internet service provider).

Exemplary electronic device

An electronic device of an exemplary embodiment of the present disclosure is explained with reference to fig. 24. The electronic device may be a client or a server.

The electronic device 2400 shown in fig. 24 is only an example, and should not bring any limitations to the functions and the scope of use of the embodiments of the present disclosure.

As shown in fig. 24, the electronic device 2400 is represented in the form of a general purpose computing device. The components of electronic device 2400 may include, but are not limited to: at least one processing unit 2410, at least one memory unit 2420, a bus 2430 to connect the various system components (including the memory unit 2420 and the processing unit 2410), and a display unit 2440.

Where the storage unit stores program code, the program code may be executed by the processing unit 2410 to cause the processing unit 2410 to perform the steps according to various exemplary embodiments of the present disclosure as described in the above-mentioned "exemplary methods" section of this specification. For example, the processing unit 2410 may perform the method steps shown in fig. 1, and so on.

The memory unit 2420 may include volatile memory units such as a random access memory unit (RAM) 2421 and/or a cache memory unit 2422, and may further include a read only memory unit (ROM) 2423.

The memory unit 2420 may also include a program/utility 2424 having a set (at least one) of program modules 2425, such program modules 2425 including but not limited to: an operating system, one or more application programs, other program modules, and program data, each of which, or some combination thereof, may comprise an implementation of a network environment.

The bus 2430 may include a data bus, an address bus, and a control bus.

The electronic device 2400 may also communicate with one or more external devices 2500 (e.g., keyboard, pointing device, bluetooth device, etc.), which may be through an input/output (I/O) interface 2450. The electronic device 2400 also includes a display unit 2440 connected to the input/output (I/O) interface 2450 for displaying. Also, the electronic device 2400 may communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network such as the internet) via the network adapter 2460. As shown, the network adapter 2460 communicates with the other modules of the electronic device 2400 over a bus 2430. It should be appreciated that although not shown in the figures, other hardware and/or software modules may be used in conjunction with the electronic device 2400, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems, to name a few.

It should be noted that although in the above detailed description several modules or sub-modules of the apparatus are mentioned, such division is merely exemplary and not mandatory. Indeed, the features and functions of two or more units/modules described above may be embodied in one unit/module according to embodiments of the present disclosure. Conversely, the features and functions of one unit/module described above may be further divided into embodiments by a plurality of units/modules.

Further, while the operations of the disclosed methods are depicted in the drawings in a particular order, this does not require or imply that the operations must be performed in this particular order, or that all of the illustrated operations must be performed, to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps combined into one step execution, and/or one step broken down into multiple step executions.

While the spirit and principles of the present disclosure have been described with reference to several particular embodiments, it is to be understood that the present disclosure is not limited to the particular embodiments disclosed, nor is the division of aspects which is intended to be construed to be merely illustrative of the fact that features of the aspects may be combined to advantage. The disclosure is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.

Claims

1. A reporting method of embedded point information is characterized by comprising the following steps:

responding to a trigger operation aiming at a client, and determining a page node tree of a target display page exposed by the trigger operation;

generating a buried point object tree according to the attribute information of the nodes in the page node tree;

and determining the buried point object to be reported based on the generated adjacent buried point object tree, and reporting buried point information according to the buried point object to be reported.

2. A reporting method of embedded point information as claimed in claim 1, wherein the determining a page node tree of a target display page exposed by the trigger operation includes:

and determining a page node tree of the target display page exposed by the trigger operation according to the interface hierarchical relationship of the target display page exposed by the trigger operation.

3. A reporting method as claimed in claim 1, wherein the generating a buried point object tree according to the attribute information of the node in the page node tree includes:

generating a buried point object tree according to whether the nodes in the page node tree are configured with target parameters or not;

the target parameter is used for indicating that the node is a buried point object.

4. A reporting method of buried point information as claimed in claim 1, wherein the determining a buried point object to be reported based on the generated adjacent buried point object tree includes:

determining a visible node in the first buried point object tree and the second buried point object tree;

determining a buried point object to be reported according to the visible node;

the first buried object tree is a buried object tree generated earlier in the adjacent buried object trees, the second buried object tree is a buried object tree generated later in the adjacent buried object trees, and the buried object indicated by the visible node is not completely blocked in the graphical user interface.

5. A reporting method as claimed in claim 1, wherein the generating a buried point object tree according to the attribute information of the node in the page node tree includes:

updating a first preset storage container according to the trigger operation and the root page of the target display page exposed by the trigger operation;

and generating a buried object tree corresponding to the root page according to the attribute information of the nodes in the page node tree corresponding to the root page aiming at each updated root page in a first preset storage container based on a preset period.

6. A reporting method of embedded point information according to claim 5, wherein the generating, for each root page updated in a first preset storage container, the embedded point object tree corresponding to the root page according to the attribute information of the node in the page node tree corresponding to the root page based on a preset period includes:

determining a time to be processed based on the preset period;

when any one to-be-processed time arrives, if the residual time of the running cycle of the main thread of the terminal equipment where the client is located is greater than or equal to a first preset value, determining that the to-be-processed time is a target time;

and at the current target time, aiming at each root page updated in the first preset storage container from the last target time to the current target time, and generating a buried point object tree corresponding to the root page according to the attribute information of the nodes in the page node tree of the root page based on the updating sequence.

7. A reporting method of buried point information as claimed in claim 5, wherein when the triggering operation includes a sliding operation, the method further includes:

collecting sliding messages of the sliding operation according to a first preset time interval, and updating a second preset storage container according to the collected sliding messages and child node identifications corresponding to the list to which the sliding operation aims;

when the first preset storage container is not updated and the second preset storage container is updated, traversing a page node tree where the child node identifiers are located from the child node identifiers on the basis of an updating sequence aiming at the child node identifiers updated in the second preset storage container so as to generate a buried point object tree;

when the first preset storage container is updated, for each updated root page in the first preset storage container, traversing a page node tree corresponding to the root page from a node corresponding to the root page based on an updating sequence to generate a buried point object tree.

8. A reporting device of embedded point information is characterized by comprising:

the page node tree determining module is configured to respond to a trigger operation aiming at a client and determine a page node tree of a target display page exposed by the trigger operation;

a buried object tree generating module configured to generate a buried object tree according to attribute information of nodes in the page node tree;

and the buried point information reporting module is configured to determine a buried point object to be reported based on the generated adjacent buried point object tree, so as to report the buried point information according to the buried point object to be reported.

9. A computer-readable storage medium, on which a computer program is stored, which program, when being executed by a processor, carries out the method according to any one of claims 1 to 7.

10. An electronic device, comprising:

one or more processors;

storage means for storing one or more programs which, when executed by the one or more processors, cause the one or more processors to carry out the method of any one of claims 1 to 7.