A mobile terminal task closure preloading mechanism based on user semantic understanding

Abstract

A mobile terminal task closure preloading mechanism based on user semantic understanding, comprising: (1) user request and device state joint collection and reporting; (2) task closure generation and historical behavior pattern enhancement; (3) task closure return and background non-disturb preloading; (4) freezing guarantee when resources are insufficient. The application can identify the application set required for completing the current task based on user semantic understanding, preloads the application related to the subsequent task in order without interrupting the current interaction, and provides resource guarantee by freezing non-critical background applications when resources are insufficient, thereby significantly reducing the cumulative cold start waiting time in the multi-application continuous use scenario, and improving the response efficiency and user experience of the mobile device.

Description

Technical Field

[0001] This invention relates to the fields of mobile operating systems, application startup optimization, intelligent preloading, and human-computer interaction understanding, and particularly to a mobile task closure preloading mechanism based on user semantic understanding. More specifically, this invention addresses the problems of long application cold start waiting times in scenarios of continuous use of multiple applications on mobile terminals, the difficulty of existing systems in identifying the user's true task objectives in advance, and the tendency of existing preloading methods to interrupt the current interaction. It proposes a task closure identification and non-intrusive preloading method that is implemented collaboratively on the mobile terminal and server side.

[0002] This invention is applicable to, but not limited to, smartphones, tablet computing devices, handheld terminals, and other mobile devices with graphical interfaces, application ecosystems, and multitasking capabilities; it is also applicable to other mobile operating system environments based on the Android system or with similar application lifecycle management mechanisms. Background Technology

[0003] With the widespread use of mobile devices in scenarios such as navigation, social networking, short videos, news, shopping, gaming, and office work, users often do not use a single application during a complete task, but rather need to switch continuously between multiple applications. For example, after reading information about a location, a user might immediately open a map application for navigation, and then further open a communication application to send their current location to a friend; similarly, after watching a product recommendation video, a user often continues to open an e-commerce application to place an order; or, while chatting, a user might further launch a game application, a forum application, or a video application to complete subsequent tasks. This kind of continuous use of multiple applications is very common in real-world mobile scenarios.

[0004] However, most existing mobile operating systems employ an on-demand launch mechanism based on discrete trigger events. The system only launches the corresponding application when the user clicks an app icon, notification entry, or deep link. In other words, existing systems primarily respond based on "what the user has already clicked," rather than preparing in advance based on "what task the user actually wants to complete next." Due to a lack of understanding of user semantics, the system cannot proactively identify the set of applications needed to complete the entire task chain before the user explicitly clicks on subsequent applications.

[0005] Under the aforementioned mechanism, each application in a multi-application scenario typically undergoes its own cold start process. A cold start generally includes operations such as reading the application's executable code from storage media, loading native libraries, initializing the runtime environment, creating or restoring critical components, parsing resource files, establishing necessary data structures, and completing initial preparations related to user interface display. These processes are usually accompanied by significant disk I / O overhead, page load overhead, and initialization overhead, resulting in substantial application startup latency. For a single application, this latency already directly impacts user experience; in scenarios with continuous use of multiple applications, this latency accumulates with the number of applications, further amplifying user waiting time.

[0006] Furthermore, even when traditional systems attempt prefetching or caching optimizations, they are often limited to localized optimizations targeting a single application, a single page, or recently accessed objects, lacking a unified perspective on the complete user task. Existing technologies struggle to answer the following questions: When a user inputs a natural language request, engages in voice interaction, or performs a behavior with a clear subsequent intent within an application, can the system pre-determine which applications the user will use, the order in which these applications will be used, whether resources need to be released for preloading, and how to complete the loading without interfering with the current foreground application?

[0007] Furthermore, simply using the traditional application launch path for "preloading" usually encounters another problem: most mobile operating systems trigger the application's main interface entry component first when launching an application. Once this component is launched, it often brings the application to the foreground, directly interrupting the user's currently active foreground application, causing screen flickering, focus switching, task interruption, and even leading to user dizziness, accidental operations, or misjudgments of abnormal system behavior. Therefore, existing launch paths are not suitable for direct use in preloading multiple applications in the background.

[0008] On the other hand, mobile devices have limited main memory resources. At certain times, system memory is already occupied by the current foreground application and several background applications. If multiple task-related applications are loaded directly without considering resource status, preloading may fail, or further trigger system-level garbage collection, frequent page switching, and passive killing of background applications. In other words, simply "identifying which applications will be loaded" is not enough; a mechanism is also needed to selectively allocate resources when resources are insufficient, ensuring that critical task applications are given priority access to main memory.

[0009] Therefore, there is an urgent need to propose a new mobile application startup optimization scheme that enables the system to identify the minimum set of applications required for a complete task based on user semantic understanding. Without interrupting the current interaction, the system can preload the applications in the set into main memory in an orderly manner. When resources are insufficient, the system can freeze non-critical background applications to reserve resources for preloading the task closure, thereby significantly reducing the cumulative waiting time in scenarios where multiple applications are used continuously. Summary of the Invention

[0010] 1. Purpose of the invention

[0011] To address the problem that existing mobile operating systems struggle to understand user task semantics, can only passively launch applications one by one via clicks, and thus lead to increased cold start waiting times in multi-application scenarios, this invention aims to provide a mobile task closure preloading mechanism based on user semantic understanding. Another objective of this invention is to provide a background preloading mechanism that does not interrupt the current foreground application interaction, enabling the system to preload applications required for subsequent tasks into main memory while the user remains on the current application interface, without frequent interface switching and interaction interruptions.

[0012] 2. Technical Solution

[0013] The technical solution of this invention is as follows: This invention sets up a user agent on the mobile terminal side and a task closure generation module on the server side, which works in conjunction with a historical user behavior pattern storage unit, a semantic generation unit, and a task closure preloading execution module, enabling the system to prepare applications to be used subsequently based on the user's current task. Based on the above overall architecture, the core technical solution of this invention can be summarized into the following four points.

[0014] (1) Joint collection and reporting of user requests and device status. The user agent on the mobile terminal side is used to receive user requests and synchronously collect the current operating status of the device. The user request preferably includes text input, speech transcription results, search statements, conversation content, or other information that can reflect the user's task intent; the device operating status preferably includes at least a portion of the following: main memory capacity, overall main memory utilization, current foreground application identifier, background application set, foreground application main memory usage, background application main memory usage, CPU cluster utilization, foreground application CPU utilization, background application CPU utilization, and overall graphics processor utilization. The user agent jointly encapsulates the user request and device status and sends them to the server side, thereby providing information input containing both semantic information and device context for task closure generation.

[0015] (2) Task Closure Generation and Historical Behavior Pattern Enhancement. A task closure generation module is set up on the server side. The task closure generation module includes at least a historical behavior pattern retrieval unit and a semantic generation unit. The historical behavior pattern retrieval unit is used to store and retrieve the user's historical behavior patterns. The historical behavior patterns are preferably recorded using a data structure containing fields such as "user needs, current foreground application, and set of background applications", and are stored in a vector database after being mapped to a vector space through an embedding model. The semantic generation unit is used to perform semantic understanding on the current user request and, in combination with the retrieved historical behavior patterns, generate the minimum set of applications required to complete the current task. If the target application is explicitly given in the user request, the semantic generation unit directly determines the task closure based on the user request; if the target application is not explicitly given in the user request, there is ambiguity, or there are multiple candidate applications, the task closure generation module enhances the inference results based on semantically similar historical behavior patterns, and completes or corrects the target application and its loading order in the task closure.

[0016] (3) Task closure return and background non-disruptive preloading. After the server generates the task closure, it returns the task closure to the mobile terminal. The task closure is preferably represented in the form of an application identifier set, and further includes the loading order of the target application; in specific implementation, the application identifier can be the application package name, application component identifier, or other software identifier that can uniquely identify the application. After receiving the task closure, the task closure preloading execution module preloads the target application in the loading order, so that the executable code, dependent libraries, and resource data of the target application are preloaded into the main memory. In order to avoid interrupting the current interaction, the preloading execution module preferably adopts a background loading path that bypasses the main interface entry component, and loads the target application without switching the current foreground interface by directly calling the non-main interface entry component or an equivalent background loading method; when the mobile terminal is currently in the desktop interface or in a state that allows for front-end startup, the target application can also be preloaded by calling the main interface entry component.

[0017] 3. Beneficial effects

[0018] Compared to existing technologies, this invention firstly identifies the set of applications required to complete a task based on user semantic understanding, thereby improving the system's response granularity from "single application" to "complete task." This allows the system to complete preparations before the user clicks on subsequent applications one by one.

[0019] This invention can significantly reduce the cumulative waiting time in scenarios where multiple applications are used continuously. Because the applications in the task closure are pre-loaded into main memory, subsequent use of these applications does not require going through a complete cold start process again, thereby reducing input / output wait caused by repeatedly loading executable code, native libraries, and resource files.

[0020] The background preloading method that bypasses the main interface entry component provided by this invention avoids the problem of frequent switching of the foreground interface caused by directly calling the application's main interface entry in the traditional way. This allows task closure preloading to be completed without disturbing the current foreground application interaction, improving the smoothness of system behavior and the consistency of user experience.

[0021] The verification results show that in 20 typical mobile usage scenarios, this invention reduces the average waiting time for users to complete a task by approximately 52.7% before all required applications are ready. Taking a typical task closure consisting of "Toutiao, Douyin, and WeChat" as an example, the cumulative waiting time under the traditional cold start method is approximately 2558.9 milliseconds, while the cumulative waiting time after adopting the task closure preloading method of this invention is approximately 1117.2 milliseconds, demonstrating a significant effect. Attached Figure Description

[0022] Figure 1 This relates to the startup time of common applications. A comparison was made between the application preloading of this invention and traditional application cold starts; preloading can significantly reduce user waiting time.

[0023] Figure 2 This diagram illustrates the system's runtime behavior. Mobile task closure preloading based on user semantic understanding can significantly reduce user waiting time when multiple applications are executing tasks.

[0024] Figure 3 The system operation flowchart shows that the system collects the current user's needs and behavioral habits on the client side, obtains historical similar user usage records through enhanced retrieval, and submits them to the large model to generate a closure that can complete the current user's task.

[0025] Figure 4 This diagram illustrates the correspondence between typical user requests and task closure generation results in this invention, used to explain the methods of task closure generation in both explicit and implicit request scenarios.

[0026] Figure 5 This invention demonstrates its performance improvement effect on different application load combinations. In 20 typical mobile use cases, this invention reduces the average waiting time for users to complete tasks before all required applications are ready by approximately 52.7%. Detailed Implementation

[0027] The specific implementation of the present invention will be further described below in conjunction with the overall process of the present invention. When the present invention is executed, the user agent on the mobile terminal side first receives user input and simultaneously collects device operation information such as the current foreground application, the set of background applications, and the status of available resources. Subsequently, the user agent sends the above information to the task closure generation module on the server side. This module performs semantic understanding of the user request and, in conjunction with historical user behavior patterns, determines the minimum set of applications required to complete the current task, thereby generating a task closure corresponding to the current task.

[0028] After the task closure is generated, the server returns the task closure to the mobile terminal. The task closure includes at least one target application identifier, and preferably includes multiple target application identifiers and their loading order. After receiving the task closure, the mobile terminal calls the task closure preloading execution module to preload the target applications in the task closure in the background, so that the execution code, dependency libraries and resource data of the relevant applications are preloaded into main memory, and the necessary initialization preparations are completed.

[0029] When a user is already in a foreground application, in order to avoid the preloading process interrupting the existing interaction, this invention preferably adopts a background loading method that bypasses the main interface entry component, so that the target application can complete the warm-up without switching the currently visible interface; when the user actually switches to the target application later, since the target application has completed part of the loading and initialization in advance, the startup path can be shortened.

[0030] Through the above process, this invention achieves a complete closed loop from user semantic understanding, task closure generation, background preloading execution to resource assurance. Compared to the traditional method that relies on users clicking one by one and then cold-starting applications individually, this invention can prepare relevant applications in advance around the user's continuous task chain, thereby significantly shortening the cumulative waiting time in scenarios of continuous use of multiple applications and improving the responsiveness and smoothness of mobile terminals.

[0031] Figure 1 This refers to the startup time of common applications. Cold start vs. preloading. Preloading can significantly reduce user waiting time. Figure 2 This is a schematic diagram of the system runtime. Mobile task closure preloading based on user semantic understanding can significantly reduce user waiting time when multiple applications are executing tasks. Figure 3 This is a system operation flowchart. The system collects the current user's needs and behavioral habits on the client side, obtains historical similar user usage records through enhanced retrieval, and submits them to the large model to generate a closure that can complete the current user's task. Figure 4 It is a task closure generated in response to user requirements. Figure 5This invention improves performance for different application load combinations. In 20 typical mobile use cases, this invention reduces the average waiting time for users to complete tasks before all required applications are ready by approximately 52.7%.

[0032] This invention provides a mobile task closure preloading mechanism based on user semantic understanding, including: (1) Joint collection and reporting of user requests and device status. The user agent on the mobile terminal side receives user requests and synchronously collects device operating status; the user requests and device operating status are jointly encapsulated and sent to the server side, thereby providing information input containing both semantic information and device context for task closure generation. (2) Task closure generation and historical behavior pattern enhancement. The server side performs semantic understanding on user requests and, in conjunction with the retrieved historical behavior patterns, generates the minimum set of applications required to complete the current task, i.e., the task closure; for requests with explicitly given target applications, the task closure is directly determined; for requests without explicitly given target applications, with semantic ambiguity, or with multiple candidate applications, the target applications and their loading order in the task closure are enhanced and inferred and completed in conjunction with historical behavior patterns. (3) Task closure return and background non-intrusive preloading. After the server generates the task closure, it returns the task closure to the mobile terminal. The mobile terminal performs preloading of the target application according to the loading order based on the returned task closure, so that the executable code, dependent libraries and resource data of the target application are preloaded into the main memory. Among them, the preloading preferably adopts the background loading method that bypasses the main interface entry component to avoid interrupting the current foreground application interaction. (4) Freezing guarantee when resources are insufficient. The server further combines the device running status reported by the mobile terminal to determine whether the current device resources are sufficient to support the preloading of all target applications in the task closure. When resources are insufficient, a set of applications to be frozen is generated and returned to the mobile terminal. The mobile terminal performs freezing operation on the corresponding background application process to reduce resource competition and release or reserve resources for the preloading of the task closure. The present invention can identify the set of applications required to complete the current task based on user semantic understanding, perform orderly preloading of applications related to subsequent tasks without interrupting the current interaction, and provide resource guarantee by freezing non-critical background applications when resources are insufficient, thereby significantly reducing the cumulative cold start waiting time in the scenario of continuous use of multiple applications and improving the response efficiency and user experience of mobile devices.

[0033] A mobile task closure preloading mechanism based on user semantic understanding includes the following steps: The mobile terminal receives a user request through a user agent and synchronously collects the current device operating status, which includes at least the current foreground application, a set of background applications, and resource status related to preloading feasibility; the user request and the device operating status are sent to a task closure generation module on the server side; the server side performs semantic understanding on the user request and generates a task closure required to complete the current task based on the device operating status, whereby the task closure is the minimum set of applications required to complete the current task; the task closure is returned to the mobile terminal side; the mobile terminal side performs preloading on the target applications contained in the task closure, so that the target applications are preloaded into main memory before the user explicitly launches them; when the current device resources are insufficient to support the task closure preloading, the server side further generates a set of applications to be frozen and returns it to the mobile terminal side, whereby the mobile terminal side freezes the corresponding background applications to provide resource guarantees for the task closure preloading.

[0034] The user request includes text input, speech-to-text transcription, search queries, conversation content, or other information that can express the user's task intent; the device operating status includes at least a portion of main memory capacity, overall main memory utilization, current foreground application identifier, background application set, foreground application main memory usage, background application main memory usage, CPU cluster utilization, foreground application CPU utilization, background application CPU utilization, and overall GPU utilization; the server side determines the minimum application set required to complete the current task based on the semantic content of the user request and the device operating status, and generates a task closure containing the target application and its pre-loading order.

[0035] The server side is equipped with a historical behavior pattern retrieval unit to record users' historical behavior patterns. The historical behavior patterns include at least user needs, the current foreground application, and a set of background applications. When a user request does not explicitly specify the target application or there is semantic ambiguity, the server side retrieves historical behavior patterns that are semantically similar to the current user request and inputs the retrieval results and the current user request into a semantic generation unit to determine the target application that matches the semantics of the current request, and corrects or completes the task closure accordingly.

[0036] The task closure is returned to the mobile terminal as a set of application identifiers, where the application identifiers are application package names, application component identifiers, or other software identifiers that can uniquely identify the application. When the mobile terminal performs preloading on the target application in the task closure, it adopts a background loading method that bypasses the main interface entry component, allowing the target application to complete background preloading without switching the current foreground interface by calling a non-main interface entry component or an equivalent background loading path. When the mobile terminal is on a desktop interface or in a state where front-end startup is allowed, the target application can be front-loaded by activating the main interface entry component of the target application.

Claims

1. A mobile task closure preloading mechanism based on user semantic understanding, characterized in that, Includes the following steps: The mobile terminal receives user requests through a user agent and simultaneously collects the current device operating status, which includes at least the current foreground application, the set of background applications, and the resource status related to preloading feasibility; the user request and the device operating status are then sent to the task closure generation module on the server side. The server performs semantic understanding on the user request and generates a task closure required to complete the current task based on the device's operating status. The task closure is the minimum set of applications required to complete the current task. The task closure is then returned to the mobile terminal. The mobile terminal preloads the target applications contained in the task closure, ensuring that the target applications are preloaded into main memory before the user explicitly launches them. If the device's current resources are insufficient to support the preloading of the task closure, the server further generates a set of applications to be frozen and returns it to the mobile terminal. The mobile terminal freezes the corresponding background applications to provide resource guarantees for the preloading of the task closure.

2. The mobile task closure preloading mechanism based on user semantic understanding according to claim 1, characterized in that, The user request includes text input, speech-to-text transcription, search queries, conversation content, or other information that can express the user's task intent; the device operating status includes at least a portion of main memory capacity, overall main memory utilization, current foreground application identifier, background application set, foreground application main memory usage, background application main memory usage, CPU cluster utilization, foreground application CPU utilization, background application CPU utilization, and overall graphics processor utilization; the server side determines the minimum application set required to complete the current task based on the semantic content of the user request and the device operating status, and generates a task closure containing the target application and its pre-loading order.

3. A mobile task closure preloading mechanism based on user semantic understanding according to claim 1 or 2, characterized in that, The server side is equipped with a historical behavior pattern retrieval unit to record users' historical behavior patterns. The historical behavior patterns include at least user needs, the current foreground application, and a set of background applications. When a user request does not explicitly specify the target application or there is semantic ambiguity, the server side retrieves historical behavior patterns that are semantically similar to the current user request and inputs the retrieval results and the current user request into a semantic generation unit to determine the target application that matches the semantics of the current request, and corrects or completes the task closure accordingly.

4. The mobile task closure preloading mechanism based on user semantic understanding according to claim 1, characterized in that, The task closure is returned to the mobile terminal as a set of application identifiers, where the application identifiers are application package names, application component identifiers, or other software identifiers that can uniquely identify the application. When the mobile terminal performs preloading on the target application in the task closure, it adopts a background loading method that bypasses the main interface entry component, allowing the target application to complete background preloading without switching the current foreground interface by calling a non-main interface entry component or an equivalent background loading path. When the mobile terminal is on a desktop interface or in a state where front-end startup is allowed, the target application can be front-loaded by activating the main interface entry component of the target application.

Images