Full page burying method and device, computer device and storage medium
By detecting the number of React Native pages and generating event tracking points based on the system environment, the problem of full event tracking for multiple React Native pages was solved, and independent full event tracking compatibility enhancement was achieved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- BEIJING VOLCANO ENGINE TECH CO LTD
- Filing Date
- 2023-12-18
- Publication Date
- 2026-06-23
Smart Images
Figure CN117807341B_ABST
Abstract
Description
Technical Field
[0001] This disclosure relates to the field of computer technology, specifically to a method, apparatus, computer device, and storage medium for full embedding of data points on a webpage. Background Technology
[0002] In the React Native framework, it's necessary to implement full event tracking for both PageView and PageLeave events to automatically generate event tracking information for native React Native (RN) pages, reducing the cost of event tracking for developers. Currently, full event tracking for PageView and PageLeave in RN pages is achieved by listening to the page's show and disappearance events and automatically collecting event tracking data for both PageView and PageLeave. However, this method is difficult to implement for RN pages within a single native page. Summary of the Invention
[0003] In view of this, the present disclosure provides a method, apparatus, computer device, and storage medium for full tracking of a page, in order to solve the problem that it is difficult to achieve full tracking of ReactNative pages when multiple ReactNative pages exist simultaneously in a native page.
[0004] In a first aspect, embodiments of this disclosure provide a method for full-tracking of a page, including: obtaining the native page of an application on a mobile terminal and the system operating environment; detecting the number of native interactive pages contained in the native page; and generating page display tracking points for entering the native interactive page and page disappearance tracking points for leaving the native interactive page based on the number of native interactive pages and the system operating environment.
[0005] The full-tracking method for pages provided in this disclosure detects the number of native interactive pages contained within a native page, and, combined with the number of native interactive pages and the system operating environment of the mobile terminal, automatically collects page display tracking and page disappearance tracking for each native interactive page. Therefore, it is no longer limited to tracking of a single native interactive page, but achieves full-tracking for multiple native interactive pages. Simultaneously, it achieves independent full-tracking for native interactive pages, no longer relying on full-tracking technology for native pages, and can achieve full-tracking integration with the system operating environment, enhancing the adaptability of tracking.
[0006] Secondly, embodiments of this disclosure provide a full-tracking device for a page, comprising: an acquisition module for acquiring the native pages of an application on a mobile terminal and the system operating environment; a detection module for detecting the number of native interactive pages contained in the native pages; and a tracking module for generating page display tracking points for entering the native interactive pages and page disappearance tracking points for leaving the native interactive pages based on the number of native interactive pages and the system operating environment.
[0007] Thirdly, this disclosure provides a computer device, including: a memory and a processor, which are communicatively connected to each other. The memory stores computer instructions, and the processor executes the computer instructions to perform the full-page embedding method of the first aspect or any corresponding embodiment described above.
[0008] Fourthly, embodiments of this disclosure provide a computer-readable storage medium storing computer instructions for causing a computer to execute the full-tracking method for pages described in the first aspect or any corresponding embodiment. Attached Figure Description
[0009] To more clearly illustrate the technical solutions in the specific embodiments of this disclosure or the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this disclosure. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.
[0010] Figure 1 This is a flowchart illustrating a full-tracking method for pages according to some embodiments of this disclosure;
[0011] Figure 2 This is a flowchart illustrating a full-tracking method for another page according to some embodiments of this disclosure;
[0012] Figure 3 This is a flowchart of the event tracking process in the iOS runtime environment according to some embodiments of this disclosure;
[0013] Figure 4 This is a flowchart of the data collection process in an Android runtime environment according to some embodiments of this disclosure;
[0014] Figure 5 This is a schematic diagram of the instrumentation triggering in the iOS runtime environment according to some embodiments of this disclosure;
[0015] Figure 6 This is a schematic diagram of the generation of event tracking points in the iOS runtime environment according to some embodiments of this disclosure;
[0016] Figure 7 This is a schematic diagram of the event tracking in the Android runtime environment according to some embodiments of this disclosure;
[0017] Figure 8 This is a schematic diagram of the generation of data points in an Android runtime environment according to some embodiments of this disclosure;
[0018] Figure 9 This is a schematic diagram illustrating the view page content according to some embodiments of this disclosure;
[0019] Figure 10 This is a schematic diagram of the data entry point triggering during view switching according to some embodiments of this disclosure;
[0020] Figure 11 This is a schematic diagram illustrating the generation of page navigation information according to some embodiments of this disclosure;
[0021] Figure 12 This is a schematic diagram of page tracking triggering in an iOS runtime environment according to some embodiments of this disclosure;
[0022] Figure 13 This is a schematic diagram illustrating the generation of tracking point triggering and page jump information according to some embodiments of this disclosure;
[0023] Figure 14 This is a schematic diagram illustrating the determination of an RN page in an iOS runtime environment according to some embodiments of this disclosure;
[0024] Figure 15 This is a schematic diagram illustrating the determination of an RN page in an Android runtime environment according to some embodiments of this disclosure;
[0025] Figure 16 This is a schematic diagram of the event triggering of foreground / background switching in an Android operating environment according to some embodiments of this disclosure;
[0026] Figure 17 This is a schematic diagram of page tracking triggering in an Android operating environment according to some embodiments of this disclosure;
[0027] Figure 18 This is a schematic diagram illustrating the recording of event tracking and page navigation information in an Android operating environment according to some embodiments of this disclosure;
[0028] Figure 19 This is a structural block diagram of a fully embedded point device for a page according to an embodiment of the present disclosure;
[0029] Figure 20 This is a schematic diagram of the hardware structure of a computer device according to an embodiment of the present disclosure. Detailed Implementation
[0030] To make the objectives, technical solutions, and advantages of the embodiments of this disclosure clearer, the technical solutions of the embodiments of this disclosure will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this disclosure, and not all embodiments. Based on the embodiments of this disclosure, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this disclosure.
[0031] Currently, to achieve full event tracking for PageView and PageLeave in the React Native framework, we listen for the display and disappearance events of iOS / Android pages. If the page is identified as a React Native page, we automatically collect event tracking data for PageView and PageLeave.
[0032] However, the aforementioned full event tracking implementation is integrated with iOS / Android full event tracking, making it difficult to implement independently of native full event tracking functionality. Furthermore, it requires use with iOS / Android software toolkits (SDKs) and cannot be used as a standalone plugin. When multiple React Native pages coexist within native iOS / Android pages, full event tracking for React Native pages is difficult to achieve, and it is also challenging to implement full event tracking for React Native pages integrated as Fragments in the Android environment.
[0033] Based on this, the technical solution disclosed herein combines the number of ReactNative pages contained in the Native page and the system operating environment of the mobile terminal to automatically collect pageview and pageleave event tracking for each ReactNative page, thereby realizing independent full event tracking for ReactNative pages. It can be used independently as a ReactNative plugin without relying on the full event tracking of Native pages. Moreover, it enables full event tracking for iOS / Android operating environments, enhancing the adaptability of event tracking.
[0034] According to an embodiment of this disclosure, a method for full-tracking of page data is provided. It should be noted that the steps shown in the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions. Furthermore, although a logical order is shown in the flowchart, in some cases, the steps shown or described may be executed in a different order than that shown here.
[0035] This embodiment provides a method for full-page event tracking, which can be used on computer devices such as mobile phones and tablets. Figure 1This is a flowchart of a full-tracking method for a page according to an embodiment of this disclosure, as follows: Figure 1 As shown, the process includes the following steps:
[0036] Step S101: Obtain the native page of the mobile terminal's application and the system operating environment.
[0037] An application is a software program that runs on a mobile device to perform a specific function. Specifically, there are many types of applications, including office applications, game applications, social applications, music applications, etc. Applications have corresponding user interfaces that allow users to interact with the program through the user interface to complete specific functions.
[0038] The application has a corresponding native application, and native pages are pages within the native application—that is, the native views of the native application. Native pages are written using native development technologies (e.g., Java or Kotlin for Android, Objective-C or Swift for iOS), and they provide direct access to the application's native functionalities and APIs. Within the application, users can switch and navigate between different native pages using navigation or routing. Each native page has its own lifecycle and state management, and can respond to user interaction events and system events.
[0039] The system runtime environment refers to the operating system environment on which the application runs. Specifically, this runtime environment can include operating systems such as iOS and Android. Different operating systems have different runtime environments and application programming interfaces (APIs), and the application must be compatible with the operating system.
[0040] Specifically, computer devices can access the operating system's runtime environment through the application programming interfaces (APIs). Furthermore, computer devices can access the application's native page by calling relevant functions and classes provided by the operating system. For example, in Android, an Intent object can be used to launch another Activity to access the corresponding native page; in iOS, NavigationController or Modal methods can be used for page navigation to open the native page.
[0041] Step S102: Detect the number of native interactive pages contained in the native page.
[0042] Native interactive pages are pages built using the React Native framework, used to present the native user interface within an application. A native page may contain one or more native interactive pages (RN pages), and each RN page is wrapped in a ReactRootView of the native page. When a native page contains only one RN page, the default tracking method can be used for event tracking. However, when a native page contains multiple RN pages, the generation of event tracking information cannot be achieved using the default method. Therefore, it is necessary to detect the number of RN pages contained in the native page to determine the appropriate event tracking method based on the number of RN pages, achieving accurate collection of event tracking information.
[0043] Specifically, to determine whether a native page contains multiple React Native (RN) pages, the code file of the native page can be parsed. Based on the structure and logic of the code file, the navigation or display logic of the native page can be determined. If the code file contains references or navigation logic to multiple RN pages, it indicates that multiple RN pages exist within the native page.
[0044] Specifically, you can also determine the number of RN pages included in the native page by viewing the integration configuration file of the RN module, such as the build.gradle file in the Android system or the Podfile file in the iOS system, and by parsing the configuration information related to the RN module configuration in the configuration file.
[0045] Specifically, you can also determine if there are multiple RN pages by checking the component usage for RN pages. For example, if multiple RN components are used in a native page, and these components involve different functions and UI presentations, then there are multiple RN pages in the native page.
[0046] Of course, testing can also be performed by running the application to determine the page's display and interaction. If multiple different React Native (RN) pages are opened in the application, it can be determined that multiple RN pages exist within the native page. The method for determining the number of native interactive pages contained within a native page is not specifically limited here; those skilled in the art can determine it according to actual needs.
[0047] Step S103: Based on the number of native interactive pages and the system operating environment, generate page display tracking points for entering native interactive pages and page disappearance tracking points for leaving native interactive pages.
[0048] Page view event tracking refers to the event tracking points generated when entering a page. Specifically, when a new page is opened or a page is returned to, a page view event tracking point (i.e., a pageview event tracking point) is generated. For example, entering the homepage will generate a pageview event tracking point for the homepage; entering the details page from the homepage will generate a pageview event tracking point for the details page; and closing the details page and returning to the homepage will generate another pageview event tracking point for the homepage.
[0049] Page leave tracking points are tracking points generated when leaving a page. Specifically, a page leave tracking point (i.e., a pageleave tracking point) is generated every time a page is left or closed. For example, when entering a details page from the homepage, a pageleave tracking point is generated for the homepage; when closing the details page and returning to the homepage, a pageleave tracking point is generated for the details page.
[0050] Based on the number of React Native (RN) pages contained within the Native page and the system operating environment, a tracking point generation strategy is determined for entering and leaving an RN page. This strategy determines when to generate page display tracking points and page disappearance tracking points. Specifically, when entering an RN page, page display tracking points are generated according to the corresponding tracking point generation strategy; when leaving an RN page, page disappearance tracking points are generated according to the corresponding tracking point generation strategy.
[0051] The full-tracking method for pages provided in this embodiment detects the number of native interactive pages contained within a native page. Combining this number with the mobile terminal's system operating environment, it automatically collects page display and page disappearance tracking data for each native interactive page. Therefore, it is no longer limited to tracking data for a single native interactive page, but achieves full-tracking tracking for multiple native interactive pages. Simultaneously, it achieves independent full-tracking tracking for native interactive pages, no longer relying on native page-based full-tracking technology, and can achieve full-tracking tracking integration with the system operating environment, enhancing the adaptability of the tracking data.
[0052] This embodiment provides a method for full-page event tracking, which can be used on computer devices such as mobile phones and tablets. Figure 2 This is a flowchart of a full-tracking method for a page according to an embodiment of this disclosure, as follows: Figure 2 As shown, the process includes the following steps:
[0053] Step S201: Obtain the native page of the mobile terminal's application and the system operating environment. For detailed explanation, please refer to the relevant descriptions in the above embodiments; they will not be repeated here.
[0054] Step S202: Detect the number of native interactive pages contained in the native page. For detailed explanation, please refer to the relevant descriptions in the above embodiments; they will not be repeated here.
[0055] Step S203: Based on the number of native interactive pages and the system operating environment, generate page display tracking points for entering native interactive pages and page disappearance tracking points for leaving native interactive pages.
[0056] Specifically, when the native page contains one native interactive page, step S203 above may include:
[0057] Step S2031: Determine the view lifecycle corresponding to the system operating environment.
[0058] The view lifecycle encompasses the creation, display, updating, and destruction of page views developed using React Native. The corresponding view lifecycle differs depending on the operating system. Specifically, for iOS, the view lifecycle is represented by the lifecycle of the UI view controller (UIViewController); for Android, the view lifecycle is represented by the lifecycle of the application's activity object (ReactActivity).
[0059] Step S2032: Determine the first time to enter the native interactive page and the second time to leave the native interactive page based on the view lifecycle.
[0060] The first timing indicator is used to characterize the optimal time to trigger page display tracking, and the second timing indicator is used to characterize the optimal time to trigger page disappearance tracking. By combining the view lifecycle, we can determine the actual entry point into the React Native (RN) page and the actual exit point from the RN page, thereby determining the first timing indicator to trigger page display tracking and the second timing indicator to trigger page disappearance tracking.
[0061] Specifically, in the iOS runtime environment, due to React Native's presentation mechanism, in the scenario of UIViewController initialization, after the page display parameters are triggered, the root view corresponding to React Native, RCTRootView, is displayed first, while the main page view, RCTRootContentView, is not displayed immediately, and the page's unique identifier, reactTag, has not yet been generated. Therefore, in the initialization scenario, the first opportunity to access the React Native page is after the main page view, RCTRootContentView, is displayed. At this time, the page's unique identifier, reactTag, has been generated, indicating that the page has truly entered the RN environment. Figure 3 As shown.
[0062] Specifically, in the Android runtime environment, due to React Native's presentation mechanism, during the initialization of the ReactActivity activity, after the page display parameters are triggered, the root view RCTRootView corresponding to React Native is displayed first, while the main body of the page is not immediately displayed, and the page's unique identifier, reactTag, has not yet been generated. Therefore, in the initialization scenario, the first opportunity occurs in the callback of the ReactInstanceManager's instance event listener, reactInstanceEventListener. At this point, the page's unique identifier, reactTag, has been generated, indicating that the RN page has truly been entered, such as... Figure 4 As shown.
[0063] Step S2033: At the first opportune moment, the generation of page display tracking points is triggered, and at the second opportune moment, the generation of page disappearance tracking points is triggered.
[0064] Upon reaching the first timing point, a hook method is used to automatically trigger the PageView event tracking, and upon reaching the second timing point, a hook method is used to automatically trigger the PageLeave event tracking. After the PageView and PageLeave event tracking are triggered, they are processed by the corresponding page stack. The page stack sends the event tracking information to the JS environment to combine the page information of the RN page and the JS environment configuration information, and generates the PageView or PageLeave event tracking by calling the corresponding methods.
[0065] Specifically, in the iOS runtime environment, the PageView and PageLeave event tracking is triggered through the Appear and Disappear hook methods in the UIViewController lifecycle, respectively. Figure 5 As shown.
[0066] After the PageView and PageLeave event tracking is triggered, the RangersAppLogNavStack sends the event tracking related to the RN page's display / hide status from the iOS runtime environment to the JavaScript environment via the RangersAppLogEmitter event sender. The JavaScript environment receives the event tracking and assembles the page information (pageInfo) by combining the PageView event tracking and the PageLeave event tracking, along with the page's unique identifier (reactTag), into the pageInfo. Then, the Track monitor collects and monitors the page information, calls the corresponding onEventV3 method to transmit the page information to the iOS runtime environment, and triggers the generation of event tracking for the page information using the application event tracking generator (e.g., RangersAppLogModule) in the iOS runtime environment. The generated PageView and PageLeave event tracking is then sent to the Software Development Kit (SDK) for management and reporting. Figure 6 As shown.
[0067] Specifically, in the Android runtime environment, the PageView and PageLeave event tracking are triggered through the ActivityResumed and ActivityPaused hook methods in the ReactActivity lifecycle of the application's activity object, respectively. Figure 7 As shown.
[0068] After the PageView and PageLeave event tracking is triggered, the RangersAppLogNavStack sends the event tracking related to the RN page's display / hide via the RangersAppLogEmitter from the Android runtime environment to the JS environment. The JS environment receives the event tracking and assembles the page information (pageInfo) by combining the PageView event tracking and the PageLeave event tracking, along with the page's unique identifier (reactTag). Then, the Track monitor collects and monitors the page information, calls the corresponding onEventV3 method to transmit the page information to the Android runtime environment, and triggers the generation of event tracking for the page information using the application event tracking generator (e.g., RangersApplogReactnativePluginModule) in the Android runtime environment. The generated PageView and PageLeave event tracking is then sent to the software development kit (SDK) for management and reporting. Figure 8 As shown.
[0069] In some alternative implementations, when the system environment is an Android runtime environment, the Pause hook is triggered when the application enters the background, and the Resume hook is triggered when it enters the foreground. This can cause PageView and PageLeave tracking points to be triggered incorrectly in these two scenarios. Therefore, it is necessary to record the Activity object that triggered Pause, and determine whether it is a foreground or background scenario in Resume, to exclude the influence of the application switching to the background in the Android runtime environment, so as to trigger PageView and PageLeave tracking points in non-background scenarios.
[0070] Accordingly, the above methods may also include:
[0071] Step a1: Obtain the first native interaction page corresponding to the first activity object that changes from a visible state to an invisible state, and the second native interaction page corresponding to the second activity object that changes from an invisible state to a visible state.
[0072] Each activity object corresponds to one page; that is, different activity objects correspond to different React Native (RN) pages. The first activity object is the activity object corresponding to the first native interaction page. The first native interaction page is the RN page that changes from a visible state to an invisible state. Specifically, this change from a visible state to an invisible state can be achieved by switching from the current RN page to another RN page, or by closing the current RN page.
[0073] The second activity object is the activity object corresponding to the second native interaction page. The second native interaction page is the RN page that changes from an invisible state to a visible state. Specifically, this change from an invisible state to a visible state can be due to switching from another RN page to the current RN page, or it can be due to opening the current RN page for the first time.
[0074] Step a2: When the second active object is different from the first active object, check whether the second active object exists.
[0075] The system checks if the second activity object is the same as the first activity object. If they are the same, it means the first and second native interaction pages are the same page, i.e., the page is simply accessed from the background. In this case, when the Resume hook method is triggered, the page is actually opened from the background, and the PageView tracking point will not be generated.
[0076] When the second activity object is different from the first activity object, it indicates that the first native interaction page and the second native interaction page are the same page, meaning the second native interaction page was not opened from the background. In this case, we can further check whether the second activity object exists. If the second activity object does not exist, proceed to step a3; otherwise, proceed to step a4.
[0077] Step a3: When the second activity object does not exist, trigger the generation of page display tracking points for the second native interaction page when entering the second native interaction page.
[0078] When the second activity object does not exist, it indicates that the second native interactive page corresponding to the second activity object is being opened for the first time. At this time, when the Resume hook method is triggered, the generation of the PageView tracking point for the second native interactive page will be triggered.
[0079] Step a4: When the second activity object exists and the user enters the third native interaction page corresponding to the third activity object from the second native interaction page corresponding to the second activity object, a page disappearance tracking point for the second native interaction interface is triggered, and a page display tracking point for the third native interaction page is triggered.
[0080] The third activity object is the activity object corresponding to the third native interactive page. The third native interactive page is a new page opened based on the second native interactive page. Specifically, when the second activity object exists, it means that the second native interactive page corresponding to the second activity object is not being opened for the first time, that is, the second native interactive page has already been displayed. At this time, after entering the third native interactive page corresponding to the third activity object, the PageLeave event tracking for the second native interactive interface needs to be triggered first, and then the PageView event tracking for the third native interactive interface needs to be triggered.
[0081] For example, if the second native interaction page is the application's homepage and the third native interaction page is a details page opened on top of the homepage, then when entering the details page from the application's homepage, the PageLeave event tracking for the application's homepage needs to be triggered first, and then the PageView event tracking for the details page needs to be triggered.
[0082] In the above implementation, under the Android operating environment, by detecting the second active object and the first active object, it is determined whether the native interactive page corresponding to the second active object exists. This can eliminate the phenomenon of false data collection caused by the application entering the background, and enable accurate collection of data collection information under the Android operating environment.
[0083] Specifically, when a native page contains multiple native interactive pages, the content of these pages may appear in different views. Therefore, it is difficult to collect event tracking information correctly using the method described for a single native interactive page. In this case, it is necessary to combine the views in which the native interactive pages are located to accurately collect event tracking information. Accordingly, step S203 may include:
[0084] Step S2034: Detect whether multiple native interactive pages are in the same view.
[0085] The view is the visible area of a computer device's screen, such as a mobile phone screen. When a native page contains multiple RN pages, because the content of these multiple RN pages is often large, it is difficult to display the content of all the RN pages in the same view. For example... Figure 9 As shown, the current view displays the content of RN page 1. The content of RN page 2 will be displayed after swiping, and the content of RN page 3 will be displayed after clicking. That is, when there is a lot of page content, some content is not visible on the first screen and requires a corresponding triggering operation to become visible. This page content that is only visible after a triggering operation belongs to a different view from the page content visible on the first screen.
[0086] Specifically, for a Native page containing multiple React Native (RN) pages, these RN pages can be concentrated in the same view; they can be distributed across different views; or they can be distributed across different views, with each view containing multiple RN pages. Therefore, it is necessary to collect event tracking information based on the different distribution patterns of the RN pages.
[0087] When it is determined that a Native page contains multiple RN pages, it is possible to check whether the various RN pages are concentrated in the same view. If multiple native interactive pages are in the same view, then step S2035 is executed; otherwise, step S2036 is executed.
[0088] Step S2035: When multiple native interactive pages are in the same view, generate page display tracking points for each native interactive page based on the display state of the view content corresponding to the view, and generate page disappearance tracking points for each native interactive page based on the hidden state of the view content corresponding to the view.
[0089] When multiple native interactive pages reside within the same view, and the view content is displayed, the content of each React Native (RN) page within that view will be displayed simultaneously, triggering a PageView event tracking point for each RN page. Conversely, when the view content is hidden, the content of each RN page within the same view will be hidden simultaneously, triggering a PageLeave event tracking point for each RN page.
[0090] Step S2036: When multiple native interactive pages are in different views, detect whether a view switch has occurred.
[0091] When multiple native interactive pages are in different views, different React Native (RN) pages will be displayed in these different views. To determine the tracking information for each RN page, it is necessary to detect whether a view switch has occurred. If a view switch occurs, step S2037 is executed; otherwise, it means that no RN page switch has occurred, and there is no need to trigger pageview or pageleave tracking for the RN page.
[0092] Step S2037: When a view switch occurs, generate page disappearance tracking points for each native interactive page contained in the previous view, and generate page display tracking points for each native interactive page contained in the current view.
[0093] The React Native (RN) pages contained within a view are displayed as the view is displayed and hidden as the view is hidden. When a view switch occurs, the RN pages displayed in the previous view disappear, triggering the `pageleave` event tracking for each RN page in the previous view. Meanwhile, the RN pages displayed in the current view appear, triggering the `pageview` event tracking for each RN page in the current view.
[0094] like Figure 10 As shown, the current view contains RN page 1 and RN page 2. When the content of the current view is in the display state, the pageview event points for RN page 1 and RN page 2 are triggered simultaneously. When a triggering operation (such as clicking) is performed to change the content of the current view to RN page 3, the pageleave event points for RN page 1 and RN page 2 are triggered first, and then the pageview event point for RN page 3 is triggered.
[0095] Step S2038: When generating page display tracking points for each native interactive page contained in the current view, update the page jump information for the current view based on the page disappearance tracking points.
[0096] When a view switch occurs, in order to collect the page navigation path of each RN page, the previous page information (refer information) of each RN page in the current view can be determined based on the pageleave tracking point while generating the pageview tracking point. The page navigation information corresponding to each RN page in the current view can be determined through the referer information.
[0097] like Figure 11 As shown, the first view is PageC, the first screen of the Native page. When switching from the first view to the second view to display RN Page 1 (RNPage1) and RN Page 2 (RNPage2), the referrer information, i.e., referrer: PageC, is obtained from the Native page in the first view. When switching from the second view to the third view to display RN Page 3 (RNPage3), the referrer information, such as referrer: RNPage2, is obtained from the RN page in the second view that most recently triggered the pageleave event.
[0098] It should be noted that although switching from the second view to the third view will trigger the pageleave event for both RN page 1 and RN page 2, there will be a certain execution time difference in the triggering of the pageleave event. Therefore, the page jump information is determined here based on the RN page that triggered the pageleave event most recently.
[0099] In some optional embodiments, when the system runtime environment is an iOS runtime environment, the method for determining whether a native interactive page exists in the current view includes:
[0100] Step b1: Detect whether the page displayed in the current view is a native interactive page.
[0101] Step b2: When the page displayed in the current view is a native interactive page, detect the first screen occupancy ratio of the native interactive page.
[0102] Step b3: When the first screen occupancy ratio exceeds the first preset threshold, it is determined that there is a native interactive page in the current view.
[0103] Step b4: When the first screen occupancy ratio is lower than the first preset threshold, it is determined that there are multiple native interactive pages in the current view.
[0104] Specifically, for the iOS runtime environment, such as Figure 12As shown, when the view content is displayed, each RN page within the same view triggers its `pageview` event handler sequentially with the `Appear` hook method of the UIViewController's lifecycle. Conversely, when the view content is hidden, each RN page triggers its `pageleave` event handler sequentially with the `Disappear` hook method of the UIViewController's lifecycle.
[0105] like Figure 13 As shown, during view switching, as the view content changes, the `pageleave` event handler for the previous RN page is triggered first, followed by the `pageview` event handler for the current RN page. When the `pageview` event handler for the current RN page is triggered, the page navigation information (i.e., referrer information) can be obtained from the page where the `pageleave` event handler was most recently triggered.
[0106] In the iOS runtime environment, each page is an instance of a UIViewController object. However, UIViewController object instances can be nested within each other, making it difficult to directly distinguish whether a UIViewController object instance is a native page or a part of a native page.
[0107] Since each RN page needs to be placed in the UIViewController, it is necessary to distinguish whether the current object instance of the UIViewController is a Native page, whether the current object instance of the UIViewController is an RN page, and whether there are multiple RN pages.
[0108] Specifically, this can be done by inspecting the view in the UIViewController to determine if a React Root View exists. If a React Root View exists, it can be determined that the page displayed by the current view is an RN page.
[0109] The first screen occupancy ratio is the percentage of screen space occupied by the RN page in the view; the first preset threshold is a pre-set percentage of screen space used to determine if the RN page is a single page, for example, 99%. Figure 14As shown, when the currently displayed page is determined to be an RN page, the first screen occupancy ratio of the RN page is compared with a first preset threshold to determine whether the first screen occupancy ratio exceeds the first preset threshold. If the first screen occupancy ratio exceeds the first preset threshold, it is determined that there is one RN page in the current view; otherwise, it is determined that there are multiple RN pages in the current view.
[0110] In the above implementation, under the iOS operating environment, when it is determined that the page displayed in the current view is a native interactive page, the number of native interactive pages displayed in the current view is determined by detecting the screen occupancy ratio. This facilitates the subsequent adoption of corresponding tracking strategies for the number of native interactive pages, thereby achieving accurate tracking of native interactive pages under the iOS operating environment.
[0111] In some alternative embodiments, when the system operating environment is an iOS operating environment, the above method may further include:
[0112] Step c1: When the page displayed in the current view is not the native interactive page, detect the second screen occupancy ratio of the page displayed in the current view.
[0113] Step c2: When the second screen occupancy ratio exceeds the second preset threshold, it is determined that the page displayed in the current view is the native page.
[0114] The second screen occupancy ratio is the percentage of screen space occupied by the Native page in the view; the second preset threshold is a pre-set threshold used to determine the percentage of screen space occupied by the Native page, such as 99%.
[0115] Specifically, such as Figure 14 As shown, if it is determined that no ReactRootView exists by inspecting the view in the UIViewController, then the page displayed by the current view can be determined to be a Native page. Further, the second screen-to-body ratio of the page corresponding to the UIViewController object instance is checked to determine if the second screen-to-body ratio exceeds a second preset threshold. If the second screen-to-body ratio exceeds the second preset threshold, the page displayed by the current view is determined to be a Native page; otherwise, the current view is determined not to be a page.
[0116] In the above implementation, under the iOS operating environment, the type of the page displayed by the current view is detected, and the tracking information is triggered and generated according to the page type to ensure the accuracy of full tracking.
[0117] In some optional embodiments, when the system runtime environment is an Android runtime environment, the method for determining whether a native interactive page exists in the current view includes:
[0118] Step d1: Check if there are any child activity objects in the current activity object.
[0119] Step d2: When there are child activity objects in the current activity object and a target root view in the child activity object, it is determined that there are multiple native interactive pages in the current view, and each child activity object corresponds to a native interactive page.
[0120] Step d3: If there are no child activity objects in the current activity object, and there is a target root view in the current activity object, it is determined that there is a native interactive page in the current view.
[0121] In the Android runtime environment, a Native page is an instance of an Activity object. Within an Activity object, multiple child Activity Fragment instances can be managed. When a Native page contains multiple React Native pages, the React RootView corresponding to each RN page is stored and managed within a child Activity Fragment. Therefore, it's necessary to distinguish between them.
[0122] Check if the Activity object has a React Root View, if the Activity object has child Fragments, and if the child Fragments have a React Root View.
[0123] Specifically, such as Figure 15 As shown, this can be done by checking the content of the current Activity to determine whether there are child Activity Fragments. If there are child Activity Fragments and the child Activity Fragments have a target root view (i.e., ReactRootView), then it is determined that there are multiple RN pages in the current view; if the child Activity Fragments have a ReactRootView, then it is determined that the child Activity Fragments do not belong to a page.
[0124] If the current Activity has no child Fragments and contains a React Root View, then the current Activity corresponds to an RN page. If the current Activity has no child Fragments and contains no React Root View, then the current Activity corresponds to a Native page.
[0125] In the above implementation, under the Android operating environment, the number of native interactive pages displayed in the current view is determined by detecting whether there are child active objects in the current active object. This facilitates the subsequent adoption of corresponding tracking strategies for the number of native interactive pages, thereby achieving accurate tracking of native interactive pages under the Android operating environment.
[0126] When the system is running in an Android environment, the Pause hook method of the child activity object Fragment is triggered when the application enters the background; similarly, the Resume hook method of the child activity object Fragment is triggered when the application enters the foreground. This causes the PageView and PageLeave event tracking points to be triggered incorrectly in these two scenarios.
[0127] To solve the above problems, such as Figure 16 As shown, when the Pause hook method corresponding to Activity1 is triggered, the information of Activity1 is recorded. When the Resume hook method of the child activity Fragment is triggered, the Activity2 to which the child activity Fragment belongs can be obtained, and the information of Activity2 is recorded. The information of Activity2 is compared with the information of Activity1. If they are the same, it means that the background has been switched to the foreground. In the scenario of switching from the background to the foreground, PageView and PageLeave tracking points are not triggered; if they are different, PageView and PageLeave tracking points are triggered normally.
[0128] In some alternative implementations, after excluding background influences, the methods for triggering PageView and PageLeave event tracking may include:
[0129] Step e1: Obtain the target activity object to which the sub-activity object belongs;
[0130] Step e2: Before triggering the generation of page display tracking points for the native interactive page corresponding to the child activity object, trigger the generation of page disappearance tracking points for the native interactive page corresponding to the child activity object in the previous target activity object.
[0131] Since the child activity Fragment belongs to the activity, when triggering the pageview event of the RN page corresponding to the child activity Fragment, it is necessary to first trigger the pageleave event of the RN page corresponding to the Fragment in the target activity object that was recorded last time, and then trigger the pageview event of the RN page corresponding to the current Fragment.
[0132] In the above implementation, under the Android operating environment, by detecting the target activity object to which the sub-activity object belongs, the page display tracking and page disappearance tracking of the native interactive page are triggered. This enables the handling of tracking triggers for native interactive pages integrated in the Fragment method, and realizes full tracking of native interactive pages integrated in the Fragment method.
[0133] In some alternative embodiments, when the system operating environment is an Android operating environment, the above method may further include:
[0134] Step f1: Obtain the first view displayed by the currently active object and the second view corresponding to the previous active object;
[0135] Step f2: When switching from the second view to the first view, generate page disappearance tracking points for the native interactive pages corresponding to all child activity objects of the previous activity object;
[0136] Step f3: Based on the page disappearance tracking point, retrieve page jump information from the previous activity object;
[0137] Step f4: Based on the page jump information, trigger the generation of page display tracking points for the native interactive pages corresponding to the child activity objects in the current activity object.
[0138] For the Android operating environment, such as Figure 17 As shown, when the view content is displayed, each RN page within the same view triggers its `pageview` event handler sequentially with the `Resume` hook method of its child activity Fragment's lifecycle. Conversely, when the view content is hidden, each RN page triggers its `pageleave` event handler sequentially with the `Pause` hook method of its child activity Fragment's lifecycle.
[0139] In the Android operating system, different activity objects correspond to different view pages. The first view is the view displayed by the current activity object, and the second view is the view corresponding to the previous activity object. When a view switch occurs, that is, when jumping from the second view corresponding to the previous activity object to the first view corresponding to the current activity object, since the first view is hidden, the PageLeave event handlers of all the React Native pages corresponding to the child activity objects of the previous activity object can be triggered, thus achieving the triggering of PageLeave event handlers for all React Native pages in the second view.
[0140] To determine the page navigation path of the RN page, after triggering the page disappearance tracking point, the page navigation information (i.e., referrer information) is retrieved from the previous activity object, and the pageview tracking point of the RN page corresponding to the child activity object in the current activity object is triggered, so as to achieve the triggering of pageview tracking points for all RN pages in the first view.
[0141] This enables support for the Fragment mode of native interactive pages, improving the compatibility of full-tracking technology.
[0142] Specifically, when an activity object contains multiple child activity objects, when navigating from the RN page corresponding to one child activity object Fragment1 to the RN page corresponding to another child activity object Fragment2, the referrer information can be obtained from Fragment1, which most recently triggered the pageleave event. For example... Figure 18 As shown, the current Activity object contains two child Activity objects, Fragment1 and Fragment2, each corresponding to a specific React Native (RN) page. When navigating from the RN page corresponding to Fragment1 to the RN page corresponding to Fragment2, the Pause hook function triggers the PageLeave event handler for the RN page corresponding to Fragment1, and records the navigation information from the RN page corresponding to Fragment1 to the most recent page. Figure 18 The LastRefer Info is shown. Before triggering the PageView event handler for the RN page corresponding to the child activity object Fragment2, the referrer information (i.e., the RN page corresponding to the child activity object Fragment1) is read from the most recent page navigation information. Then, the PageView event handler for the RN page corresponding to the child activity object Fragment2 is triggered by the Resume hook function, and the PageView event handler for the RN page corresponding to the child activity object Fragment2 is recorded.
[0143] In the above implementation, when a view switch occurs, the page disappearance tracking point of the native interactive page corresponding to all sub-activity objects in the previous activity object is triggered, and the page display tracking point of the native interactive page corresponding to the sub-activity objects in the current activity object is triggered according to the page jump information of the previous activity object.
[0144] The full tracking method for pages provided in this embodiment, when a native page contains one native interactive page, determines the timing of triggering page display tracking and page disappearance tracking by combining the view lifecycle corresponding to the system runtime environment. This allows for accurate collection of tracking information for a single native interactive page, facilitating full tracking for that single page. When a native page contains multiple native interactive pages, the method detects the views in which the multiple native interactive pages reside and automatically collects page display tracking and page disappearance tracking for each native interactive page by combining view switching. This achieves full tracking for multiple native interactive pages in the iOS / Android runtime environment, no longer limited to the collection of tracking information for a single native interactive page, improving the inclusiveness of tracking information collection and expanding the application scenarios of tracking information collection. When generating page display tracking, updating the page jump information of the view through page display tracking can clarify the page jump path, facilitating the improvement of page tracking accuracy by combining page jump information.
[0145] This embodiment also provides a full-page embedding device for implementing the above embodiments and preferred embodiments, and details already described will not be repeated. As used below, the term "module" can be a combination of software and / or hardware that implements a predetermined function. Although the device described in the following embodiments is preferably implemented in software, hardware implementation, or a combination of software and hardware, is also possible and contemplated.
[0146] This embodiment provides a full-featured data tracking device for a webpage, such as... Figure 19 As shown, it includes:
[0147] The acquisition module 301 is used to acquire the native page of the mobile terminal application and the system operating environment.
[0148] The detection module 302 is used to detect the number of native interactive pages contained in the native page;
[0149] The event tracking module 303 is used to generate page display tracking points when entering a native interactive page and page disappearance tracking points when leaving a native interactive page, based on the number of native interactive pages and the system operating environment.
[0150] In some optional embodiments, when the native page contains one native interactive page, the aforementioned tracking module 303 may include:
[0151] The lifecycle determination unit is used to determine the view lifecycle corresponding to the system operating environment.
[0152] The trigger timing unit is used to determine the first timing for entering the native interactive page and the second timing for leaving the native interactive page based on the view lifecycle.
[0153] The event tracking unit is used to trigger the generation of event tracking points when the page is displayed at the first time, and to trigger the generation of event tracking points when the page disappears at the second time.
[0154] In some optional embodiments, when the system operating environment is an Android operating environment, the above-mentioned data tracking module may further include:
[0155] The page acquisition unit is used to acquire the first native interactive page corresponding to the first active object that changes from a visible state to an invisible state, and the second native interactive page corresponding to the second active object that changes from an invisible state to a visible state.
[0156] The detection unit is used to detect whether the second active object exists when the second active object is different from the first active object.
[0157] The first event trigger unit is used to generate page display event points for the second native interaction page when entering the second native interaction page, even if the second activity object does not exist.
[0158] The second event triggering unit is used to trigger the generation of page disappearance event for the second native interactive interface and page display event for the third native interactive page when the second active object exists and the user enters the third native interactive page corresponding to the third active object from the second native interactive page corresponding to the second active object.
[0159] In some alternative embodiments, when the native page contains multiple native interactive pages, the aforementioned tracking module 303 may include:
[0160] The view detection unit is used to detect whether multiple native interactive pages are in the same view.
[0161] The third event trigger unit is used to generate page display event points for each native interactive page based on the display state of the view content corresponding to the view when multiple native interactive pages are in the same view, and to generate page disappearance event points for each native interactive page based on the hidden state of the view content corresponding to the view.
[0162] The view switching detection unit is used to detect whether a view switching has occurred when multiple native interactive pages are in different views.
[0163] The fourth event trigger unit is used to generate page disappearance event points for each native interactive page contained in the previous view and page display event points for each native interactive page contained in the current view when a view switch occurs.
[0164] In some alternative embodiments, the above-mentioned data tracking module 303 may include:
[0165] The jump information determination unit is used to update the page jump information for the current view based on the page disappearance tracking when generating page display tracking for each native interactive page contained in the current view.
[0166] In some alternative embodiments, when the system operating environment is an iOS operating environment, the above-described apparatus may further include:
[0167] The page type detection module is used to detect whether the page displayed in the current view is a native interactive page.
[0168] The first screen occupancy detection module is used to detect the first screen occupancy of the native interactive page when the current view displays a native interactive page.
[0169] The first determination module is used to determine that there is a native interactive page in the current view when the first screen occupancy ratio exceeds the first preset threshold; and to determine that there are multiple native interactive pages in the current view when the first screen occupancy ratio is lower than the first preset threshold.
[0170] In some alternative embodiments, when the system operating environment is an iOS operating environment, the above-described apparatus may further include:
[0171] The second screen occupancy detection module is used to detect the second screen occupancy of the page displayed in the current view when the page displayed in the current view is not the native interactive page.
[0172] The second determination module is used to determine that the page displayed in the current view is the native page when the second screen occupancy ratio exceeds the second preset threshold.
[0173] In some alternative embodiments, when the system operating environment is an Android operating environment, the above-described apparatus may further include:
[0174] The active object detection module is used to detect whether there are child active objects in the current active object.
[0175] The page determination module is used to determine that there are multiple native interactive pages in the current view when there are child active objects in the current active object and a target root view in the child active object, with each child active object corresponding to one native interactive page; when there are no child active objects in the current active object and a target root view exists in the current active object, it determines that there is one native interactive page in the current view.
[0176] In some alternative embodiments, when the system operating environment is an Android operating environment, the above-described apparatus may further include:
[0177] The Activity Object Acquisition module is used to obtain the target activity object to which the sub-activity object belongs.
[0178] The event tracking module is used to trigger the generation of event tracking for the page display of the native interactive page corresponding to the child activity object in the previous target activity object, before triggering the generation of event tracking for the page display of the native interactive page corresponding to the child activity object.
[0179] In some alternative embodiments, when the system operating environment is an Android operating environment, the above-described apparatus may further include:
[0180] The view acquisition module is used to obtain the first view displayed by the currently active object and the second view corresponding to the previous active object.
[0181] The first event tracking module is used to trigger the generation of page disappearance tracking points for the native interactive pages corresponding to all child event objects in the previous event object when switching from the second view to the first view.
[0182] The jump information retrieval module is used to retrieve page jump information from the previous activity object based on the page disappearance tracking point.
[0183] The second event tracking module is used to trigger the generation of page display event points for the native interactive pages corresponding to the sub-event objects in the current event object based on page navigation information.
[0184] The further functional descriptions of each module and unit are the same as those in the corresponding embodiments described above, and will not be repeated here.
[0185] In this embodiment, the full-embedded page device is presented in the form of a functional unit. Here, a unit refers to an ASIC circuit, a processor and memory that execute one or more software or fixed programs, and / or other devices that can provide the above functions.
[0186] The full-tracking device for pages provided in this embodiment detects the number of native interactive pages contained within a native page. Combining this number with the mobile terminal's system operating environment, it automatically collects page display and page disappearance tracking data for each native interactive page. Therefore, it is no longer limited to tracking data for a single native interactive page, but achieves full-tracking tracking for multiple native interactive pages. Simultaneously, it achieves independent full-tracking tracking for native interactive pages, no longer relying on native page-based full-tracking technology, and can achieve full-tracking tracking integration with the system operating environment, enhancing the adaptability of the tracking data.
[0187] This disclosure also provides a computer device having Figure 19 The page shown has a fully embedded tracking device.
[0188] Please see Figure 20 , Figure 20 This is a schematic diagram of the structure of a computer device provided in an optional embodiment of this disclosure, such as... Figure 20 As shown, the computer device includes one or more processors 10, memory 20, and interfaces for connecting the components, including high-speed interfaces and low-speed interfaces. The components communicate with each other via different buses and can be mounted on a common motherboard or otherwise installed as needed. The processors can process instructions executed within the computer device, including instructions stored in or on memory to display graphical information of a GUI on external input / output devices (such as display devices coupled to the interfaces). In some alternative implementations, multiple processors and / or multiple buses can be used with multiple memories and multiple memory modules, if desired. Similarly, multiple computer devices can be connected, each providing some of the necessary operations (e.g., as a server array, a group of blade servers, or a multiprocessor system). Figure 20 Take a processor 10 as an example.
[0189] Processor 10 may be a central processing unit, a network processor, or a combination thereof. Processor 10 may further include a hardware chip. The hardware chip may be an application-specific integrated circuit (ASIC), a programmable logic device (PLD), or a combination thereof. The programmable logic device may be a complex programmable logic device (CAMP), a field-programmable gate array (FPGA), a general-purpose array logic (GPA), or any combination thereof.
[0190] The memory 20 stores instructions executable by at least one processor 10 to cause the at least one processor 10 to perform the method shown in the above embodiments.
[0191] The memory 20 may include a program storage area and a data storage area. The program storage area may store the operating system and applications required for at least one function; the data storage area may store data created based on the use of the computer device. Furthermore, the memory 20 may include high-speed random access memory and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some alternative embodiments, the memory 20 may optionally include memory remotely located relative to the processor 10, and these remote memories may be connected to the computer device via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.
[0192] The memory 20 may include volatile memory, such as random access memory; the memory may also include non-volatile memory, such as flash memory, hard disk or solid-state drive; the memory 20 may also include a combination of the above types of memory.
[0193] The computer device also includes an input device 30 and an output device 40. The processor 10, memory 20, input device 30, and output device 40 can be connected via a bus or other means. Figure 20 Taking the example of a connection between China and Israel via a bus.
[0194] Input device 30 can receive input numerical or character information, and generate key signal inputs related to user settings and function control of the computer device, such as a touchscreen, keypad, mouse, trackpad, touchpad, joystick, one or more mouse buttons, trackball, joystick, etc. Output device 40 may include display devices, auxiliary lighting devices (e.g., LEDs), and haptic feedback devices (e.g., vibration motors). The aforementioned display devices include, but are not limited to, liquid crystal displays, light-emitting diodes, displays, and plasma displays. In some alternative embodiments, the display device may be a touchscreen.
[0195] The computer device also includes a communication interface for communicating with other devices or communication networks.
[0196] This disclosure also provides a computer-readable storage medium in which the methods described in this disclosure can be implemented in hardware or firmware, or implemented as recordable on a storage medium, or implemented as computer code originally stored on a remote storage medium or a non-transitory machine-readable storage medium and subsequently stored on a local storage medium after being downloaded over a network. Thus, the methods described herein can be processed by software stored on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. The storage medium may be a magnetic disk, optical disk, read-only memory, random access memory, flash memory, hard disk, or solid-state drive, etc.; further, the storage medium may also include combinations of the above types of memory. It is understood that computers, processors, microprocessor controllers, or programmable hardware include storage components capable of storing or receiving software or computer code that, when accessed and executed by the computer, processor, or hardware, implements the methods shown in the above embodiments.
[0197] Although embodiments of the present disclosure have been described in conjunction with the accompanying drawings, those skilled in the art can make various modifications and variations without departing from the spirit and scope of the present disclosure, and such modifications and variations all fall within the scope defined by the appended claims.
Claims
1. A method for full-scale data tracking on a webpage, characterized in that, include: Obtain the native page of the mobile terminal application and the system operating environment; Detect the number of native interactive pages contained in the native page; Based on the number of native interactive pages and the system operating environment, page display tracking points for entering the native interactive page and page disappearance tracking points for leaving the native interactive page are generated; When the native page contains multiple native interactive pages, generating page display tracking points for entering the native interactive page and page disappearance tracking points for leaving the native interactive page, based on the number of native interactive pages and the system operating environment, includes: detecting whether the multiple native interactive pages are in the same view; when the multiple native interactive pages are in the same view, generating page display tracking points for each native interactive page based on the display state of the view content corresponding to the view, and generating page disappearance tracking points for each native interactive page based on the hidden state of the view content corresponding to the view; when the multiple native interactive pages are in different views, detecting whether a view switch has occurred; when a view switch occurs, generating page disappearance tracking points for each native interactive page contained in the previous view, and generating page display tracking points for each native interactive page contained in the current view.
2. The method according to claim 1, characterized in that, When the native page contains one native interactive page, the generation of page display tracking points for entering the native interactive page and page disappearance tracking points for leaving the native interactive page, based on the number of native interactive pages and the system operating environment, includes: Determine the view lifecycle corresponding to the system operating environment; The first time to enter the native interactive page and the second time to leave the native interactive page are determined based on the view lifecycle. The page display event is triggered at the first opportune moment, and the page disappearance event is triggered at the second opportune moment.
3. The method according to claim 2, characterized in that, When the system operating environment is an Android operating environment, it also includes: Get the first native interaction page corresponding to the first activity object that changes from a visible state to an invisible state, and the second native interaction page corresponding to the second activity object that changes from an invisible state to a visible state; When the second activity object is different from the first activity object, check whether the second activity object exists; When the second activity object does not exist, page display tracking points for the second native interaction page are generated when entering the second native interaction page.
4. The method according to claim 3, characterized in that, Also includes: When the second activity object exists, and the user enters the third native interaction page corresponding to the third activity object from the second native interaction page corresponding to the second activity object, a page disappearance tracking point for the second native interaction page is triggered, and a page display tracking point for the third native interaction page is also triggered.
5. The method according to claim 1, characterized in that, Also includes: When generating page display tracking points for each of the native interactive pages contained in the current view, update the page navigation information for the current view based on the page disappearance tracking points.
6. The method according to claim 1, characterized in that, When the system operating environment is an iOS operating environment, it also includes: Detect whether the page currently displayed in the view is a native interactive page; When the page displayed in the current view is the native interactive page, the first screen occupancy ratio of the native interactive page is detected; When the first screen occupancy ratio exceeds the first preset threshold, it is determined that there is a native interactive page in the current view; When the first screen occupancy ratio is lower than the first preset threshold, it is determined that there are multiple native interactive pages in the current view.
7. The method according to claim 6, characterized in that, Also includes: When the page displayed in the current view is not the native interactive page, the second screen occupancy ratio of the page displayed in the current view is detected; When the second screen occupancy ratio exceeds the second preset threshold, the page displayed in the current view is determined to be the native page.
8. The method according to claim 1, characterized in that, When the system operating environment is an Android operating environment, it also includes: Check if there are child active objects in the current active object; When the current activity object contains a sub-activity object, and the sub-activity object contains a target root view, it is determined that there are multiple native interactive pages in the current view, and each sub-activity object corresponds to one native interactive page; When there are no child activity objects in the current activity object, and the target root view exists in the current activity object, it is determined that there is a native interactive page in the current view.
9. The method according to claim 8, characterized in that, Also includes: Obtain the target activity object to which the sub-activity object belongs; Before triggering the generation of page display tracking points for the native interactive page corresponding to the sub-activity object, trigger the generation of page disappearance tracking points for the native interactive page corresponding to the sub-activity object in the previous target activity object.
10. The method according to claim 8, characterized in that, Also includes: Get the first view displayed by the currently active object and the second view corresponding to the previous active object; When switching from the second view to the first view, a page disappearance tracking point is triggered to generate native interactive pages corresponding to all sub-activity objects in the previous activity object; Based on the page disappearance tracking point, retrieve page jump information from the previous activity object; Based on the page jump information, trigger the generation of page display tracking points for the native interactive pages corresponding to the sub-activity objects in the current activity object.
11. A fully embedded point device for a webpage, characterized in that, include: The acquisition module is used to acquire the native pages of the mobile terminal's application and the system's operating environment; The detection module is used to detect the number of native interactive pages contained in the native page; The event tracking module is used to generate page display tracking points when entering the native interactive page and page disappearance tracking points when leaving the native interactive page, based on the number of native interactive pages and the system operating environment. When a native page contains multiple native interactive pages, the event tracking module includes: a view detection unit, used to detect whether the multiple native interactive pages are in the same view; a third event tracking triggering unit, used to generate page display event tracking for each native interactive page based on the display state of the view content corresponding to the view when the multiple native interactive pages are in the same view, and to generate page disappearance event tracking for each native interactive page based on the hidden state of the view content corresponding to the view; a view switching detection unit, used to detect whether a view switching has occurred when the multiple native interactive pages are in different views; and a fourth event tracking triggering unit, used to generate page disappearance event tracking for each native interactive page contained in the previous view and generate page display event tracking for each native interactive page contained in the current view when the view switching occurs.
12. A computer device, characterized in that, include: A memory and a processor are communicatively connected, the memory stores computer instructions, and the processor executes the computer instructions to perform the full-point embedding method for the page according to any one of claims 1-10.
13. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions for causing a computer to execute the full-tracking method for the page according to any one of claims 1-10.