Page usage behavior data statistics method, device and storage medium based on Flutter without embedding points
By taking over all component pages in the Flutter development framework and providing a global statistical interface, the problem of each page component in the existing technology needs to write buried statistical code, which improves development efficiency and realizes the use behavior of using the page without buried points Statistics.
Patent Information
- Application Number
- CN202011221837.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2020-11-05
- Publication Date
- 2024-11-12
- Estimated Expiration
- Not applicable · inactive patent
AI Technical Summary
In the Flutter development framework, existing page usage behavioral data statistics methods require writing tedious burying statistics code in each page component, resulting in repetitive work, easy to miss errors, and low development efficiency.
At the system level, take over all component pages, provide a global statistical interface, generate page lifecycle global listener instance objects, trigger page lifecycle method, obtain the page name indicated by the parameter to upload the full lifecycle statistics to avoid being uploaded on each page Write buried code in the component.
Reduce repetitive labor, avoid missing errors, significantly improve development efficiency, and realize page usage behavior data statistics without writing cumbersome codes.
Smart Images

Figure CN112463519B_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of computer technology, and in particular to a method, device and storage medium for non-embedded point statistics of page usage behavior data based on Flutter. Background Art
[0002] Flutter is an open source UI toolkit from Google Inc. It is a cross-platform development framework that helps developers efficiently build beautiful multi-platform applications through a set of code bases, supporting mobile terminals (iOS, Android), Web, desktop and embedded platforms. As we all know, after a product is developed and delivered to users, in order to better collect user usage behavior and adjust and optimize the product, data statistics are needed. Among them, page behavior statistics are very important and the most basic, which obtains user page usage behavior data. The page usage behavior data includes the number of page visits, page access paths, page access duration, etc.
[0003] By analyzing the data obtained from user behavior monitoring, application providers can understand user behavior habits in more detail and clearly, thereby finding problems with application provider products or marketing such as websites, mobile applications, and promotion channels, which helps application providers develop products that better meet user needs and discover high-conversion rate pages. Therefore, user page usage data analysis is extremely important, that is, after obtaining basic data on platform visits such as website or APP pages, the relevant data is counted and analyzed to find out the rules of user visits to websites or APP platforms, and these rules are combined with product optimization strategies or online marketing strategies, so as to find out possible problems in current product design or online marketing activities, and provide a basis for further optimizing products or revising online marketing strategies.
[0004] In the Flutter development framework, everything is a widget. If you want to count the above page behaviors, you can only do so in the page component StatefulWidget lifecycle method provided by the Flutter SDK. The page component lifecycle refers to the complete process of a page from creation to initialization, suspension, resumption, and destruction. The existing page component lifecycle methods include the state initialization method initState and the destruction method onDispose, which is recorded as page entry in the state initialization method and page exit in the destruction method.
[0005] The existing page usage behavior data statistics method, that is, the page component life cycle statistics method, has the following disadvantages: each page component needs to write a point-of-use statistics code, which results in a lot of repetitive and inefficient labor and is prone to omissions and errors. The point-of-use statistics code refers to a piece of code written at a certain location during program execution, which sends a network request containing original information such as event name, timestamp, device, etc. to the server, which saves the original information for subsequent data calculations.
[0006] Based on this, the present invention takes over all component pages uniformly at the system level and exposes a global statistical interface to developers, so that there is no need to write point-embedded statistical code in each page component, reducing duplication of work, avoiding omissions and errors, and greatly improving development efficiency. Summary of the invention
[0007] In view of the above problems, the present invention provides a method, device and storage medium for non-embedded statistics of page usage behavior data based on Flutter. The present invention takes over all component pages in a unified manner at the system level and exposes a global statistical interface to developers, so that there is no need to write embedded statistical code in each page component, thereby reducing duplication of work, avoiding omissions and errors, and greatly improving development efficiency.
[0008] On the one hand, the present invention provides a method for non-embedded point statistics of page usage behavior data based on Flutter, and its technical solution is as follows:
[0009] A method for collecting statistics on page usage behavior data based on Flutter, which is characterized by:
[0010] Generate a page life cycle global listener instance object, and pass the page life cycle global listener instance object to the page state abstract class;
[0011] Trigger the page life cycle global listener instance object corresponding to the page entry method B, page pause method, page resume method, page destruction method;
[0012] When the page life cycle changes, the page state abstract class calls back the four interface methods of the page entry method B, page pause method, page resume method, and page destruction method of the page life cycle global listener instance object;
[0013] By obtaining the page name indicated by the parameters in the above four interface methods, the statistical data of the entire life cycle of the page can be uploaded.
[0014] Specifically, the page entry method B, page pause method, page recovery method, and page destruction method of the global listener instance object that triggers the page life cycle include: entering the page, triggering the corresponding page entry method A, and triggering the page entry method B of the global listener instance object of the entire life cycle of the page in the page entry method; page switching or application switching, resulting in page suspension, recovery, and destruction, and triggering the page suspension method, page recovery method, and page destruction method of the global listener instance object of the page life cycle.
[0015] Furthermore, after the statistical data of the entire life cycle of the page is uploaded, the statistical background performs data analysis and display.
[0016] Further, the application is opened, the Flutter framework is started, the run application method is executed, and the material application component is returned to the Flutter framework.
[0017] Furthermore, the method further includes: passing a global navigation listener instance object into the navigation listener construction parameter of the material application component to listen to switching events of all pages in the application.
[0018] Furthermore, the method further includes: in the page entry method A, calling the add listener method of the component binding class provided by the Flutter architecture to pass in the component listener instance object to monitor the status of different applications.
[0019] Furthermore, the method also includes: when the user operates the page, a corresponding page operation method will be triggered, and when the page operation method is invoked, at least one parameter will be passed in; by obtaining the page indicated in the at least one parameter, it is determined whether the page is in a paused state or a resumed state.
[0020] Furthermore, the method also includes: when the user returns to the system desktop or jumps to other applications, by rewriting the application life cycle state change method of the component listener, when the application state changes, obtaining whether the current application is in a resumed state or a paused state for the user.
[0021] Furthermore, the method also includes: when a page changes from a paused state to a resumed state, the time between the paused state and the resumed state of the page is not counted into the actual usage time of the page; when a page changes from a paused state to a resumed state, the number of visits to the page is counted only once.
[0022] On the other hand, a non-embedded point statistics device for page usage behavior data based on Flutter is also provided, characterized in that the device includes a processor and a memory, and the memory stores at least one instruction, at least one program, a code set or an instruction set. The at least one instruction, the at least one program, the code set or the instruction set is loaded and executed by the processor to implement any of the above-mentioned non-embedded point statistics methods for page usage behavior data based on Flutter.
[0023] On the other hand, a computer-readable storage medium is also provided, characterized in that at least one instruction, at least one program, a code set or an instruction set is stored in the storage medium, and the at least one instruction, at least one program, a code set or an instruction set is loaded and executed by a processor to implement any of the above-mentioned Flutter-based page usage behavior data non-embedded point statistics methods.
[0024] The method, device and storage medium for non-embedded point statistics of page usage behavior data based on Flutter provided in this application have the following technical effects:
[0025] The present invention provides a method, device and storage medium for non-buried point statistics of page usage behavior data based on Flutter. By passing the global listener instance object of the page life cycle to the page state abstract class, when the page life cycle changes, the page state abstract class calls back the four interface methods corresponding to the instance object, and obtains the page name indicated by the parameters in the four interface methods to upload page statistics data, so there is no need to write cumbersome buried point codes. The present invention takes over all component pages uniformly at the system level and exposes the global statistics interface to developers, so there is no need to write buried point statistics code for each page component, reducing duplication of work, avoiding omissions and errors, and greatly improving development efficiency. BRIEF DESCRIPTION OF THE DRAWINGS
[0026] Figure 1 It is a schematic diagram of a method for non-embedded point statistics of page usage behavior data based on Flutter provided in an embodiment of the present invention.
[0027] Figure 2 It is a workflow diagram provided by an embodiment of the present invention. DETAILED DESCRIPTION
[0028] In order to enable those skilled in the art to better understand the technical solution of the present invention, the technical solution in the embodiment of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiment of the present invention. Obviously, the described embodiment is only an embodiment of a part of the present invention, not all of the embodiments, and this embodiment is only used to explain the present invention and does not constitute a limitation on the scope of protection of the present invention. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without making creative work should fall within the scope of protection of this application.
[0029] Those skilled in the art will appreciate that, unless otherwise stated, the singular forms "a", "an", "said" and "the" used herein may also include plural forms. It should be further understood that the term "comprising" used in the specification of the present invention refers to the presence of the features, integers, steps, operations, elements and / or components, but does not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components and / or groups thereof.
[0030] It will be understood by those skilled in the art that, unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as generally understood by those skilled in the art in the art to which the present invention belongs. It should also be understood that terms such as those defined in general dictionaries should be understood to have meanings consistent with the meanings in the context of the prior art, and will not be interpreted with idealized or overly formal meanings unless specifically defined as herein.
[0031] Those skilled in the art can understand that the terms "page", "application", "page access", "page component life cycle" and the like used herein are applicable to mobile terminals or Web or desktop or embedded platforms, and the "application" can be application software or system software. The "device" described in the present invention may include: computers, tablet computers, mobile phones, wearable devices (such as bracelets, etc.), and the like.
[0032] It should be noted that the page entry method A and the page entry method B, wherein A and B are used to distinguish two different page entry methods.
[0033] First, the technical terms that may be involved in the present invention are briefly described:
[0034] Flutter: It is an open source UI toolkit from Google Inc. and a cross-platform development framework that helps developers efficiently build exquisite multi-platform applications through a set of code bases. It supports mobile (iOS, Android), Web, desktop and embedded platforms.
[0035] Page component life cycle: refers to the complete process of a page from creation to initialization, suspension, resumption, and destruction.
[0036] The tracking point statistics code refers to a piece of code written at a certain location when the program is running. Its function is to send a network request containing original information such as event name, timestamp, device, etc. to the server. The server will save the original information for subsequent data calculations.
[0037] After a product is developed and delivered to the user, data statistics are needed to better collect user behavior and adjust and optimize the product. Among them, the most important and basic is page behavior statistics, including page visit counts, page visit paths, page visit duration, etc.
[0038] The following describes a specific embodiment of the method for non-embedded point statistics of page usage behavior data based on Flutter of the present invention. Figure 1 This is a schematic diagram of a method for non-embedded point statistics of page usage behavior data based on Flutter of the present invention. The present invention provides method operation steps as described in this embodiment or flowchart, but more or fewer operation steps may be included based on conventional or non-creative labor. The sequence of steps listed in the embodiment is only one way of executing the sequence of many steps and does not represent the only execution sequence. The execution subject of the method may be a terminal, and the terminal may specifically include software running in a physical device, such as an application installed on the device, etc., and may also include at least one of the physical devices of the type of smartphones, tablet computers, digital assistants, smart wearable devices, etc., with applications installed. Specifically, an operating system runs on the terminal, and the operating system may be an operating system such as iOS (Apple mobile terminal operating system) or Android operating system.
[0039] Embodiment 1 of the present invention, as Figure 1 As shown, a method for non-embedded point statistics of page usage behavior data based on Flutter is described, and the specific implementation method is as follows:
[0040] Generate a page life cycle global listener instance object, and pass the page life cycle global listener instance object to the page state abstract class.
[0041] Specifically, a page life cycle global listener BasePageStateObservable instance object is generated, and the page life cycle global listener instance object is passed to the page state abstract class BasePageState.
[0042] Trigger the page entry method B, page pause method, page recovery method, and page destruction method corresponding to the global listener instance object of the page life cycle. That is, enter the page, trigger the corresponding page entry method A, and trigger the page entry method B of the global listener instance object of the page's entire life cycle in the page entry method A; page switching or application switching causes the page to be suspended, restored, or destroyed, and triggers the page suspension method, page recovery method, and page destruction method of the global listener instance object of the page life cycle.
[0043] Specifically, entering the page triggers the corresponding page entry method onInitState (for clear description, recorded as "page entry method A"), and triggers the page entry method onInitState(State state) of the page's entire life cycle global listener BasePageStateObservable instance object in the page entry method onInitState (for clear description, recorded as "page entry method B"); subsequent page pause, restoration, and destruction caused by page switching and / or application switching will trigger the page pause method onPause(State state), page restoration method onResume(State state), and page destruction method onDispose(State state) of the life cycle global listener BasePageStateObservable instance object.
[0044] When the page life cycle changes, the page state abstract class calls back the page life cycle global listener instance object's page entry method B, page pause method, page resume method, and page destroy method. By obtaining the page name indicated by the parameters in the above four interface methods, the statistical data of the page's entire life cycle is uploaded.
[0045] Specifically, the page life cycle global listener BasePageStateObservable provides four interface methods: page entry method onInitState(State state), page pause method onPause(State state), page recovery method onResume(State state), and page destruction method onDispose(State state). Developers pass the page life cycle global listener BasePageStateObservable instance object to the page state abstract class BasePageState. When the page life cycle changes, the page life cycle global listener BasePageStateObservable instance object is called through the page state abstract class BasePageState. These four interface methods, that is, interface callbacks, developers obtain the page name (state.widget.toString) indicated by the parameter state in these four interface methods, and can upload statistical data without writing cumbersome embedding code.
[0046] After the statistical data of the entire life cycle of the page is uploaded, the statistical background will perform data analysis and display.
[0047] The method described in this embodiment also includes: when the user operates the page, the corresponding page operation method will be triggered, and when the page operation method is invoked, at least one parameter will be passed in; by obtaining the page indicated in the at least one parameter, it is determined whether the page is in a paused state or a resumed state.
[0048] It should be noted here that the pause and resume states when switching between applications are realized by monitoring the states of different applications through the component listener WidgetsBindingObserver. That is, when the user returns to the system desktop or jumps to other applications, the application lifecycle state change method didChangeAppLifecycleState of the component listener will be triggered. By overriding this method, it is possible to obtain in real time whether the current application is resumed (application visible) or paused (application invisible) to the user when the application state changes.
[0049] Specifically, if the application state changes from the resume state (visible state) to the pause state, such as pressing the Home button to return to the desktop or switch to other applications, then the top-level page of the application also becomes the pause state accordingly; if the application state changes from the pause state to the resume state (visible state), such as clicking the application icon from the desktop to open the application again or switching back to the application from other applications, then the top-level page of the application also becomes the resume state (visible state) accordingly.
[0050] The method described in this embodiment also includes: when the user returns to the system desktop or jumps to other applications, by rewriting the application life cycle state change method of the component listener, when the application state changes, it is obtained whether the current application is in a resumed state or a paused state for the user.
[0051] It should be noted here that the pause and resume states of page switching are achieved by globally monitoring all page switching events in the application through the navigation listener GlobalNavigatorObserver. That is, when the user opens a page, exits a page, removes a page, or replaces a page, the corresponding opening method didPush, exit method didPop, removal method didRemove, and replacement method didReplace will be triggered.
[0052] As can be seen from these method signatures, when the Flutter framework invokes these methods, it will pass in route (Route <dynamic>Type) and previousRoute(Route <dynamic>Type), the present invention determines whether the page is in a paused or resumed state by obtaining the page indicated in the previousRoute parameter.
[0053] Specifically: when the opening method didPush and the replacement method didReplace are called, if the page indicated by the parameter previousRoute is the current page, then the current page is about to enter the pause state; when the exit method didPop and the removal method didRemove are called, if the page indicated by the parameter previousRoute is the current page, then the current page is about to enter the resume state.
[0054] The full life cycle of the page described in the present invention includes an initialization state, a pause state, a resume state, and a destruction state.
[0055] When a page is resumed from a paused state, the time between the paused state and the resumed state is not counted in the actual usage time of the page. When a page is resumed from a paused state, the number of visits to the page is counted only once.
[0056] Specifically, the user first enters the first-level page, and the state of the first-level page is called "initialization"; through a certain operation, the user enters the second-level page, and the first-level page is invisible to the user but not destroyed. At this time, the state of the first-level page is called "pause"; when the user returns to the first-level page from the second-level page, the first-level page is visible to the user again, and the state of the first-level page is called "recovery"; if the user then exits the first-level page through a certain operation, the state of the first-level page is called "destruction". The full life cycle of a page consists of four states: initialization, pause, recovery, and destruction. The time from the pause state to the recovery state of the first-level page is not included in its actual usage time, otherwise the page access time statistics will be larger than the actual time. From the pause state to the recovery state of the first-level page, it is counted as one page entry, otherwise the number of page visits will be smaller than the actual time. The first-level page and the second-level page have their own complete life cycles. The entry of the second-level page will cause the first-level page to change from visible to invisible, so that the life cycle of the first-level page changes from initialization to pause. In order to illustrate the problem, only the life cycle of the first-level page is concerned here.
[0057] When a page enters the initialization state, the time the page is in the initialization state is counted into the actual usage time of the page; when the page is in the paused state, the time the page is in the paused state is not counted into the actual usage time of the page; when the page is in the resumed state, the time the page is in the resumed state is counted into the actual usage time of the page; when the page exits and enters the destruction state, the time the page is in the destruction state is not counted into the actual usage time of the page.
[0058] Embodiment 2 of the present invention, compared with the above-mentioned embodiment 1, this embodiment 2 further includes the following:
[0059] Open the application, the Flutter framework starts, executes the runApp method of the application, and returns the material application component MaterialApp to the Flutter framework.
[0060] Pass the global navigation listener GlobalNavigatorObserver instance object to the navigation listener construction parameter navigatorObservers of the material application component MaterialApp to listen to the switching events of all pages in the application.
[0061] In the page entry method, the addObserver method of the component binding class WidgetsBinding provided by the Flutter architecture is called to pass in the component listener WidgetsBindingObserver instance object to monitor the status of different applications.
[0062] Embodiment 3 of the present invention provides a non-embedded point statistics device for page usage behavior data based on Flutter, characterized in that the device includes a processor and a memory, and the memory stores at least one instruction, at least one program, a code set, or an instruction set. The at least one instruction, the at least one program, the code set, or the instruction set is loaded and executed by the processor to implement any of the above-described non-embedded point statistics methods for page usage behavior data based on Flutter.
[0063] Embodiment 4 of the present invention provides a computer-readable storage medium, characterized in that the storage medium stores at least one instruction, at least one program, a code set, or an instruction set, and the at least one instruction, at least one program, a code set, or an instruction set is loaded and executed by a processor as described in any of the above-mentioned methods for non-embedded statistics of page usage behavior data based on Flutter.
[0064] Optionally, in an embodiment of the present application, the above-mentioned storage medium may include but is not limited to: a USB flash drive, a read-only memory (ROM), a random access memory (RAM), a mobile hard disk, a magnetic disk or an optical disk, and other media that can store program codes.
[0065] The overall workflow of the present invention is shown in the attached Figure 2 shown.
[0066] Open the application, the Flutter framework starts, executes the runApp method of the application, and returns the material application component MaterialApp to the Flutter framework.
[0067] Pass the global navigation listener GlobalNavigatorObserver instance object to the navigation listener construction parameter navigatorObservers of the material application component MaterialApp to start monitoring the switching events of all pages in the application.
[0068] Generate a BasePageStateObservable instance object of the page life cycle global listener and pass it to the page state abstract class BasePageState.
[0069] Enter the page and trigger the corresponding page entry method onInitState (for clear description, recorded as "page entry method A"). In this method, call the addObserver method of the component binding class WidgetsBinding provided by the Flutter architecture to pass in the component listener WidgetsBindingObserver instance object to start application status monitoring.
[0070] At the same time, the page entry method onInitState(State state) of the page life cycle global listener BasePageStateObservable instance object is triggered in the page entry onInitState method (for clear description, recorded as "page entry method B").
[0071] Subsequent page pauses, resumes, and destructions caused by page switching and application switching will trigger the page pause method onPause(State state), page resume method onResume(State state), and page destruction method onDispose(State state) of the lifecycle global listener BasePageStateObservable instance object.
[0072] In the corresponding method of the BasePageStateObservable instance object of the lifecycle global listener, upload statistical data.
[0073] The statistical background is used for data analysis and display.
[0074] The present invention provides a method, device and storage medium for non-buried point statistics of page usage behavior data based on Flutter. By passing the global listener instance object of the page life cycle to the page state abstract class, when the page life cycle changes, the page state abstract class calls the four interface methods corresponding to the instance object, and obtains the page name indicated by the parameters in the four interface methods to upload page statistics data, so there is no need to write cumbersome buried point codes. The present invention takes over all component pages uniformly at the system level and exposes the global statistics interface to developers, so there is no need to write buried point statistics code for each page component, reducing duplication of work, avoiding omissions and errors, and greatly improving development efficiency.
[0075] It should be noted that the above-mentioned sequence of the embodiments of the present application is for description only and does not represent the advantages and disadvantages of the embodiments. The above-mentioned specific embodiments of this specification are described. Other embodiments are within the scope of the attached claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the embodiments and still achieve the desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.
[0076] The same or similar parts between the various embodiments in this specification can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the device, equipment, and storage medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.
[0077] A person skilled in the art will understand that all or part of the steps to implement the above embodiments may be accomplished by hardware, or may be accomplished by instructing the relevant hardware through a program, and the program may be stored in a computer-readable storage medium, and the above-mentioned storage medium may be a read-only memory, a disk or an optical disk, etc.
[0078] The basic principles, main features and advantages of the present invention are shown and described above. Those skilled in the art should understand that the above description is only a preferred embodiment of the present invention, and the present invention is not limited to the above embodiment. The above embodiment and the description are only to illustrate the principle of the present invention. Without departing from the spirit and scope of the present invention, the present invention may have various changes and improvements, and these changes and improvements fall within the scope of the present invention claimed for protection. The scope of protection claimed for the present invention is defined by the attached claims and their equivalents.< / dynamic> < / dynamic>
Claims
1. There is no method for collecting statistics on page usage behavior data based on Flutter. It is characterized in that include: Generate a page life cycle global listener instance object, and pass the page life cycle global listener instance object to the page state abstract class; Triggering the page entry method B, page pause method, page recovery method, and page destruction method corresponding to the global listener instance object of the page life cycle, including: entering the page, triggering the corresponding page entry method A, and triggering the page entry method B of the global listener instance object of the page life cycle in the page entry method A; page switching or application switching causes the page to be paused, restored, and destroyed, and triggers the page pause method, page recovery method, and page destruction method of the global listener instance object of the page life cycle; When the page life cycle changes, the page entry method B, page pause method, page resume method, and page destruction method corresponding to the page life cycle global listener instance object are called back through the page status abstract class; By obtaining the page name indicated by a parameter in the four interface methods corresponding to the page entry method B, page pause method, page recovery method, and page destruction method of the global listener instance object of the page life cycle, the statistical data of the page's entire life cycle is uploaded; The method further includes: opening the application, starting the Flutter framework, executing the running application method, returning the material application component to the Flutter framework, passing the global navigation listener instance object to the navigation listener construction parameter of the material application component, and monitoring the switching events of all pages in the application; The method also includes: when the user operates the page, the corresponding page operation method will be triggered, and when the page operation method is invoked, at least one parameter will be passed in, and the parameter is the previousRoute parameter; by obtaining the page indicated in the at least one parameter, it is determined whether the page is in a paused state or a resumed state.
2. According to the Flutter-based page usage behavior data non-embedded point statistics method according to claim 1, Features: After the statistical data of the entire life cycle of the page is uploaded, the statistical background performs data analysis and display.
3. According to the Flutter-based page usage behavior data non-embedded point statistics method according to claim 1, It is characterized in that The method further includes: in the page entry method A, calling the add listener method of the component binding class provided by the Flutter architecture to pass in the component listener instance object to monitor the status of different applications.
4. According to the Flutter-based page usage behavior data non-embedded point statistics method according to claim 3, It is characterized in that The method also includes: when the user returns to the system desktop or jumps to other applications, by rewriting the application life cycle state change method of the component listener, when the application state changes, obtaining whether the current application is in a resumed state or a paused state for the user.
5. According to the Flutter-based page usage behavior data non-embedded point statistics method according to claim 4, It is characterized in that The method also includes: when a page changes from a pause state to a resume state, the time between the pause state and the resume state of the page is not counted in the actual usage time of the page; when the page changes from a pause state to a resume state, the number of visits to the page is counted as only once.
6. There is no point-of-use statistics device for Flutter-based page usage behavior data. It is characterized in that The device includes a processor and a memory, wherein at least one instruction, at least one program, a code set, or an instruction set is stored in the memory, and the at least one instruction, the at least one program, the code set, or the instruction set is loaded and executed by the processor to implement the Flutter-based page usage behavior data non-embedded point statistics method as described in any one of claims 1 to 5.
7. A computer-readable storage medium, It is characterized in that The storage medium stores at least one instruction, at least one program, a code set, or an instruction set, and the at least one instruction, at least one program, a code set, or an instruction set is loaded by a processor and executed by the Flutter-based page usage behavior data non-embedded point statistics method as described in any one of claims 1 to 5.
