Methods and equipment for processing specific tasks and storage media.

Abstract

DEPCT63 This request pertains to the methods and suite of task-specific program processing equipment and storage media. And the computer equipment method has parts that are: displaying the first child program specific to the task. The first child task program is executed by the parent task program; it uses the program. The first child task seeks to receive the program identifier for the second child task, which is compatible with the program. Only the second child task will be jumped to by the parent task program. According to the second child task program, when a jump occurs from the first child task program. Also, a second, task-specific child program; transferring data of functions corresponding to program identifiers. Specifically, the second child task is directed to the second child task program; and the program page is generated. Only the second child task above the first child task program page, based on the page information, and display the page. Second child-specific program -----------------------------------------------------------

Description

Application processing methods, devices and storage media

[0001] This application claims priority to Chinese Patent Application No. 201710524874.0, filed on June 30, 2017, entitled "Application Processing Method, Apparatus, Storage Medium and Computer Equipment", the entire contents of which are incorporated herein by reference. Technical Field

[0002] This application relates to the field of computer technology, and in particular to an application processing method, apparatus and storage medium.

[0003] background

[0004] An application is a sequence of coded instructions that can be executed by a computer or other terminal with information processing capabilities to achieve a certain result, or a sequence of symbolic instructions or symbolic statements that can be automatically converted into coded instructions. Currently, users can install various applications on their terminals, such as camera applications, social networking applications, or email applications, thereby enabling various functions, such as camera functions, social networking functions, or email management functions.

[0005] Technical content

[0006] This application provides an application processing method, apparatus, and storage medium.

[0007] An application processing method, applied to a terminal, the method comprising:

[0008] Displays the first child application page of the first child application run by the parent application;

[0009] The first sub-application obtains the identifier of the second sub-application to which the user is to jump, wherein when the first sub-application jumps to the second sub-application, the parent application runs the second sub-application.

[0010] The page data corresponding to the second sub-application identifier is passed to the second sub-application;

[0011] Based on the page data, a second sub-application page is generated and overlaid on the first sub-application page, and the second sub-application page is displayed.

[0012] An application processing apparatus includes a processor and a memory, the memory storing computer-readable instructions that can cause the processor to:

[0013] Display the first sub-application page of the first sub-application run by the parent application; obtain the corresponding second sub-application identifier of the second sub-application to which the parent application is to jump through the first sub-application, wherein the parent application runs the second sub-application when the first sub-application jumps to the second sub-application; pass the page data corresponding to the second sub-application identifier to the second sub-application; generate the second sub-application page covering the first sub-application page according to the page data, and display the second sub-application page.

[0014] A computer-readable storage medium storing computer-readable instructions, which, when executed by a processor, cause the processor to perform the following steps:

[0015] Displays the first child application page of the first child application run by the parent application;

[0016] The first sub-application obtains the identifier of the second sub-application to which the user is to jump, wherein when the first sub-application jumps to the second sub-application, the parent application runs the second sub-application.

[0017] The page data corresponding to the second sub-application identifier is passed to the second sub-application;

[0018] Based on the page data, a second sub-application page is generated and overlaid on the first sub-application page, and the second sub-application page is displayed.

[0019] Brief description of the attached figures

[0020] Figure 1 is an application environment diagram of the application processing system in one embodiment of this application;

[0021] Figure 2 is a flowchart illustrating an application processing method in one embodiment of this application;

[0022] Figure 3 is a schematic diagram of the relationship between the operating system, the parent application, the child application, and the pages of the child application in one embodiment of this application;

[0023] Figure 4 is a schematic diagram of the sub-application return in one embodiment of this application;

[0024] Figure 5 is a schematic diagram of the closing of a sub-application in one embodiment of this application;

[0025] Figure 6 is a schematic diagram of sub-application jump in one embodiment of this application;

[0026] Figure 7 is a flowchart illustrating the application processing method in another embodiment of this application;

[0027] Figure 8 is a structural block diagram of an application processing device in one embodiment of this application;

[0028] Figure 9 is a module structure diagram of the parent application in one embodiment of this application;

[0029] Figure 10 is a module structure diagram of the parent application in another embodiment of this application;

[0030] Figure 11 is an internal structural diagram of a computer device in one embodiment of this application.

[0031] Implementation

[0032] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0033] Figure 1 is an application environment diagram of an application processing system according to one embodiment of this application. Referring to Figure 1, the application processing system includes a terminal 110 and a server 120. The terminal 110 and the server 120 are connected via a network. An operating system runs on the terminal 110, and a parent application runs on the operating system. The terminal 110 implements the application processing method through the parent application to achieve sub-application navigation. Specifically, the terminal 110 can create a sub-application logic layer unit and a corresponding sub-application view layer unit through the parent application. The sub-application view layer processing unit can be used to generate sub-application pages. The server 120 can store the data required to generate sub-application pages, such as page data corresponding to the sub-application identifier.

[0034] Figure 2 is a flowchart illustrating an application processing method in one embodiment of this application. This embodiment primarily uses the application of this method to the terminal 110 in Figure 1 as an example. Referring to Figure 2, the application processing method specifically includes the following steps:

[0035] S202, Display the sub-application page (or first sub-application page) of the sub-application (or first sub-application) run by the parent application.

[0036] Specifically, the terminal runs an operating system, and the parent application runs on the operating system. An operating system (OS) is a computer program that manages and controls the hardware and software resources of the terminal. It is the most basic system software that runs directly on the terminal's bare metal, and applications require the support of the operating system to run. The operating system can be a desktop operating system such as Windows, Linux, or Mac OS (Apple's desktop operating system), or a mobile operating system such as iOS (Apple's mobile operating system) or Android.

[0037] The parent application is the native application. A native application is an application that can run directly on the operating system. The parent application can be a social application, an email application, or a game application, etc. Social applications include instant messaging applications, SNS (Social Network Service) applications, or live streaming applications, etc. Specifically, the parent application can be the WeChat app.

[0038] Figure 3 illustrates a schematic diagram of the relationship between the operating system, the parent application, the child application, and the pages of the child application in one embodiment of this application. Referring to Figure 3, an operating system 301 runs on the terminal, and a parent application 302 runs on the operating system 301. The parent application 302 provides an environment for the running of the child application. The terminal can create a child application logic layer unit 304 and a corresponding child application view layer unit 305 to implement the child application based on the child application's package. The child application logic layer unit 304 can be used to execute the page logic code in the package, and the child application view layer unit 305 can be used to execute the page structure code in the package, and can also execute the page style code in the package. The page logic code, page structure code, and page style code in the package can be collectively referred to as page code.

[0039] In one embodiment, when a sub-application is to be run in the environment provided by the parent application, the terminal can create a sub-application logic layer unit 304 and a corresponding sub-application view layer unit 305 through the parent application. The terminal can then obtain the application package corresponding to the sub-application and the page data corresponding to the sub-application through the parent application 302, and obtain the page code from the application package. The page code may include page logic code, page structure code, and page style code.

[0040] The terminal can then execute page structure code through the sub-application view layer unit 305. According to the identifier of the public component defined in the executed page structure code, it selects the public component corresponding to the identifier from the public component library, obtains the default component style data that comes with the public component, organizes the public component according to the default component style data, applies the page data to the public component and renders it to form a sub-application page and display it, thereby displaying the sub-application page of the sub-application run by the parent application.

[0041] The page structure code defines the components of the page. It may include identifiers for common components. The page style code defines the page's style. The page logic code defines the processing logic for the corresponding sub-application page. Common components are shared by pages in different sub-applications; they have a visual appearance and are the building blocks of the sub-application page. Each common component has a unique identifier, which may be its name.

[0042] S204, through the sub-application, obtain the corresponding sub-application identifier (or second sub-application identifier) ​​of the sub-application to which the user is to jump (or the second sub-application), wherein when the first sub-application jumps to the second sub-application, the parent application runs the second sub-application.

[0043] The sub-application identifier is used to uniquely identify a sub-application. After each sub-application runs within the parent application, the parent application can assign a unique sub-application identifier (such as an APP ID) to each sub-application. Each sub-application can be opened using its unique identifier. For example, after sub-applications (such as shared bikes, coupons, etc.) run within WeChat, WeChat will assign an APP ID to each sub-application to uniquely identify it. When switching from the shared bike sub-application to the coupon sub-application, the shared bike sub-application will obtain the coupon sub-application's APP ID to open it. The sub-application identifier can be a string containing at least one of the following characters: numbers, letters, and symbols, such as X123456789.

[0044] Specifically, the terminal can detect or listen to events triggered within the currently displayed sub-application page (i.e., the first sub-application page) through the sub-application to which it belongs (i.e., the first sub-application). This event triggers a jump from the currently displayed sub-application page to another sub-application (i.e., the second sub-application). This event can be a trigger operation targeting a jump entry point. The jump entry point can be an icon, link, or virtual button, etc. Alternatively, this event can be triggered after a specific event occurs. For example, during payment, selecting a payment method triggers an event that jumps to the sub-application corresponding to the selected payment method.

[0045] When the terminal detects or listens to an event that triggers a jump from the currently displayed sub-application page to another sub-application page through the sub-application page to which the terminal belongs, it obtains the corresponding sub-application identifier (i.e., the second sub-application identifier) ​​of the sub-application to which the terminal is to jump.

[0046] In one embodiment, the sub-application identifier of the sub-application to which the user is to be redirected can be carried in the redirect entry. The sub-application to which the currently displayed sub-application page belongs can extract the sub-application identifier encapsulated in the redirect entry after detecting a trigger operation on the redirect entry. The sub-application identifier of the sub-application to which the user is to be redirected can also be the sub-application identifier of the currently displayed sub-application page, found based on the detected or listened-to time.

[0047] S206, the page data corresponding to the sub-application identifier (or the second sub-application identifier) ​​is passed to the sub-application (or the second sub-application) that corresponds to the sub-application identifier and is run by the parent application.

[0048] Page data refers to the data presented in the sub-application pages. Page data can be text, audio, video, or image data, etc. It can be dynamic or static. Dynamic data can be continuously changing or periodically changing.

[0049] In one embodiment, the page data corresponding to the sub-application identifier can be page data included in a uniformly selected page for the sub-application corresponding to the sub-application identifier. The uniformly selected page could be, for example, the sub-application's homepage, which is the page directly displayed after the sub-application is loaded. Alternatively, the page data corresponding to the sub-application identifier can also be page data belonging to a specific page within the sub-application corresponding to the sub-application identifier. For example, the page data of the page containing the email content in an email application, or the page data of the page containing weather information in a weather application.

[0050] Specifically, the terminal can obtain the global logic file of the sub-application to which it is to jump through the parent application, create a sub-application logic layer unit based on the global logic file, obtain the global configuration file of the sub-application corresponding to the sub-application identifier, obtain the sub-application page configuration file specified by the global configuration file, and create a sub-application view layer unit based on the sub-application page configuration file.

[0051] Furthermore, the sub-application logic layer unit initiates a page data retrieval request to obtain page data corresponding to the sub-application to which the user is to be redirected. The parent application then retrieves the page data corresponding to the sub-application to which the user is to be redirected, either from the server corresponding to the parent application or from the server corresponding to the sub-application. After obtaining the page data, the parent application passes it to the sub-application view layer unit.

[0052] The terminal can create the sub-application logic layer unit and sub-application view layer unit corresponding to the sub-application to which it is to be redirected by calling the sub-application launch interface provided by the parent application, or by switching to the parent application page that triggers the sub-application redirection, thereby triggering the creation of the sub-application logic layer unit and sub-application view layer unit corresponding to the sub-application to which it is to be redirected. The sub-application launch interface can be, for example, the launch JSAPI.

[0053] In one embodiment, the terminal may also send the page data retrieval request to the server corresponding to the parent application through the parent application, so that the server corresponding to the parent application can retrieve the page data corresponding to the sub-application to which the user is to be redirected from the server corresponding to the sub-application to which the user is to be redirected.

[0054] In one embodiment, the terminal obtains the sub-application identifier of the sub-application to which it is to be redirected and the sub-application identifier of the currently displayed sub-application page through the sub-application. The terminal then sends the two sub-application identifiers and the redirection relationship between the sub-applications to the server. The server checks whether the received redirection relationship between the sub-applications is allowed. If the received redirection relationship between the sub-applications is blocked, the default page data is returned.

[0055] Here, when sub-application A needs to jump to sub-application B (i.e., the jump relationship is A→B), the parent application (such as WeChat) or its corresponding server (such as the WeChat server) checks the list of sub-applications that sub-application A can jump to (this list lists the sub-applications that sub-application A has permission to jump to) and the list of sub-applications that sub-application B can jump to (this list lists the sub-applications that sub-application B has permission to jump to). If sub-application A has permission to jump to sub-application B and sub-application B has permission to jump to sub-application A, then the jump relationship A→B is valid; otherwise, the jump relationship A→B is blocked, that is, sub-application A is not allowed to jump to sub-application B.

[0056] If the received navigation relationship between sub-applications is allowed, then the validity of the sub-application to which the user is to navigate is checked. If the sub-application to which the user is to navigate is valid, the corresponding page data of the sub-application to which the user is to navigate is returned; if the sub-application to which the user is to navigate is invalid, the default page data is returned.

[0057] For example, if a child application A running in the parent application intends to navigate to another child application B, the parent application will send the navigation relationship from A to B, along with the child application identifiers for A and B, to the server. The server checks whether navigation from A to B is allowed. If not, it returns the default page data; if allowed, it further checks whether B is valid. If valid, it returns the corresponding page data for B; otherwise, it returns the default page data.

[0058] In one embodiment, the page data corresponding to the sub-application identifier includes data passed by the sub-application corresponding to the currently displayed sub-application page. The data passed by the sub-application corresponding to the currently displayed sub-application page may be the page path and page parameters of the sub-application to which the user is to be redirected, or it may be data that can be populated into the sub-application page of the sub-application to which the user is to be redirected.

[0059] In one embodiment, after obtaining the sub-application identifier of the sub-application to which the terminal is to be redirected, the terminal can check whether the code package corresponding to the sub-application identifier is stored locally. If the code package corresponding to the sub-application identifier is not detected, the terminal obtains the page data of the default loading page, generates the default loading page and overlays it on the already displayed sub-application page for display, downloads the code package from the server corresponding to the sub-application identifier, and executes the code in the code package to run the corresponding sub-application.

[0060] S208, based on the page data, generate a sub-application page (i.e., a second sub-application page) that is overlaid on the already displayed sub-application page (i.e., the first sub-application page) and displayed.

[0061] Specifically, the terminal can execute the page structure code corresponding to the sub-application identifier through the sub-application view layer unit corresponding to the sub-application identifier. According to the identifier of the public component defined in the executed page structure code, the terminal selects the public component corresponding to the identifier from the public component library, obtains the default component style data that comes with the public component, organizes the public component according to the default component style data, applies the page data to the public component and renders it, generating a sub-application page that is overlaid on the already displayed sub-application page for display.

[0062] In one embodiment, the terminal can use the parent application to overlay the sub-application page generated by the sub-application view layer unit corresponding to the sub-application identifier based on page data onto the already displayed sub-application page.

[0063] In one embodiment, the sub-application view layer unit corresponding to the sub-application identifier, which generates the sub-application page based on the page data, may also be automatically overlaid on the already displayed sub-application page for display.

[0064] In the above application processing method, a parent application runs on the operating system, and child applications are run by the parent application, displaying the child application's page. When a child application jump is needed, the parent application only needs to obtain the corresponding child application identifier from the child application to which it wants to jump. It can then pass the page data corresponding to that identifier to the child application running by the parent application. The child application then generates a new child application page based on the page data, overlaying the already displayed child application page, automatically achieving the child application jump. This avoids the time-consuming process of exiting the currently used application and restarting the intended application, improving application efficiency.

[0065] Through the above technical solutions, sub-applications can achieve functional cooperation, forming a collaborative environment. For example, some sub-applications focus on platform-related (e.g., job search platforms) and professional (e.g., coupon) functions, serving other sub-applications; while others focus on business functions (e.g., bike sharing). This reduces development costs and time for each sub-application, while also expanding their depth and breadth (e.g., through functional cooperation, each sub-application becomes increasingly powerful, expanding its depth; and through the aforementioned jump function, one sub-application can jump to other sub-applications, expanding its breadth). For instance, WeChat (the parent application) has a sub-application for managing coupons, providing membership card management functions. Other sub-applications that need membership card functions can jump to the coupon (sub-application) through the aforementioned jump function to manage membership cards, such as member registration and points management. This allows other sub-applications to easily integrate membership card functions without expending corresponding manpower and resources.

[0066] In one embodiment, after S204, the application processing method further includes: obtaining a jump path for recording the jump relationship of sub-applications; moving the obtained sub-application identifier to the end of the jump path when the obtained sub-application identifier exists in the jump path; and adding the obtained sub-application identifier to the end of the jump path when the obtained sub-application identifier does not exist in the jump path.

[0067] The jump path includes the identifiers of the sub-applications arranged in the order of the jumps, recording the jump relationships between the sub-applications. For example, a jump path that records the jump relationship of "jumping from sub-application A to sub-application B and then to sub-application C" is: A→B→C.

[0068] Specifically, the terminal can obtain the jump path used to record the jump relationship of sub-applications through the parent application, traverse the sub-application identifiers in the obtained jump path, and compare the traversed sub-application identifier with the obtained sub-application identifier. If the parent application determines that the traversed sub-application identifier is the same as the obtained sub-application identifier, it moves the traversed sub-application identifier to the end of the jump path. If the parent application determines that none of the traversed sub-application identifiers are the same as the obtained sub-application identifier, it directly adds the obtained sub-application identifier to the end of the jump path.

[0069] For example, suppose the terminal obtains the navigation path "A→B→C" through the parent application. If the current intention is to navigate from the sub-application corresponding to C to the sub-application corresponding to B, and B already exists in "A→B→C", then B is moved to the end of "A→B→C", resulting in "A→C→B". If the current intention is to navigate from the sub-application corresponding to C to the sub-application corresponding to D, and D does not exist in "A→B→C", then D is directly added to the end of "A→B→C", resulting in "A→B→C→D".

[0070] In one embodiment, when the obtained sub-application identifier exists in the redirection path, the terminal can detect through the parent application whether the sub-application with the obtained sub-application identifier is currently running in the environment provided by the parent application. If so, the terminal queries the page path of the sub-application with the obtained sub-application identifier at runtime. If the page path of the sub-application at runtime is inconsistent with the page path of the sub-application page to which the current intended redirection is made, it is not necessary to close the sub-application first; the reload interface can be called to generate the sub-application page to which the current intended redirection is made. The reload interface may specifically be Relaunch JSAPI, etc.

[0071] In this embodiment, when navigating between sub-applications within the environment provided by the parent application, the navigation relationships between the sub-applications are recorded, allowing for a step-by-step return to each visited sub-application.

[0072] In one embodiment, the application processing method further includes: obtaining a return instruction based on the sub-application to which the currently displayed sub-application page belongs; determining the corresponding sub-application identifier of the currently displayed sub-application page in response to the return instruction; searching for a sub-application identifier that is adjacent to and precedes the determined sub-application identifier in the jump path; and returning the sub-application page corresponding to the found sub-application identifier.

[0073] The return instruction is used to return to the previous sub-application (i.e., the third sub-application, which may be the same as or different from the first sub-application). The return instruction can be passively triggered or actively triggered. A passively triggered instruction is one that is automatically triggered by the sub-application to which the currently displayed sub-application page belongs after detecting a triggering event. An actively triggered instruction is one that is actively triggered by the sub-application to which the currently displayed sub-application page belongs.

[0074] In one embodiment, the terminal can detect or listen to events triggered within the currently displayed sub-application page through the sub-application to which the currently displayed sub-application page belongs. These events trigger a return from the currently displayed sub-application page to the previously launched sub-application (i.e., the third sub-application). The event can be a trigger action for an entry point such as an icon or virtual button. The trigger action can be a touch operation, a click operation (e.g., clicking control 400 in Figure 4), or a swipe operation (e.g., a right swipe on the page shown in Figure 4).

[0075] In one embodiment, the terminal can automatically trigger a return instruction after a specific operation is performed by the sub-application to which the currently displayed sub-application page belongs. For example, if the currently displayed sub-application page belongs to a payment sub-application, then the payment sub-application will automatically trigger a return instruction to the previous sub-application after the payment is completed. This automatic triggering of the return instruction can be achieved by calling a return interface provided by the parent application. Specifically, the return interface could be an interface such as the Back JSAPI.

[0076] In one instance, when the terminal returns to a sub-application based on a return command, it can obtain the data that the currently returning sub-application needs to pass to the sub-application to which it is to return, and then pass the obtained data to the sub-application to which it is to return. Typically, returns triggered by calling the return interface provided by the parent application will involve data transfer.

[0077] Specifically, after obtaining a return instruction from the sub-application to which the currently displayed sub-application page belongs, the terminal responds to the return instruction by determining the corresponding sub-application identifier for the currently displayed sub-application page. Then, in the navigation path, it searches for a sub-application identifier that is adjacent to and precedes the determined sub-application identifier, and returns to the sub-application page corresponding to the found sub-application identifier.

[0078] In one embodiment, returning the sub-application page corresponding to the found sub-application identifier includes: when the sub-application corresponding to the found sub-application identifier is running from the parent application in the background state, returning the sub-application page displayed when the sub-application corresponding to the found sub-application identifier is redirected; when the sub-application corresponding to the found sub-application identifier has finished running, returning the default sub-application page corresponding to the found sub-application identifier.

[0079] In this context, "running in the background" refers to the parent application running the application but not displaying the page through the view layer. "Foreground" is the concept corresponding to "background." "Running in the foreground" means the parent application is running the application and displaying the page through the view layer. When navigating from one sub-application to another, the navigating sub-application is not closed but continues to run in the background by the parent application until it is manually closed or closed by the parent application due to a timeout. For example, it will be closed if it runs in the background for more than ten minutes.

[0080] Specifically, after the terminal determines the sub-application to which it wants to return through the parent application, it can search for the corresponding sub-application identifier in the sub-application runtime management list. If a sub-application identifier is found in the sub-application runtime management list, it means that the sub-application to which the terminal wants to return is running in the background by the parent application. The terminal can then use the parent application to switch the sub-application to which the terminal wants to return to to the foreground and display the sub-application page that would be displayed when the navigation occurs.

[0081] If no sub-application identifier corresponding to the sub-application to which the user is to return is found in the sub-application running management list, it means that the sub-application to which the user is to return has terminated. The terminal can obtain the page data of the default sub-application page corresponding to the sub-application to which the user is to return through the parent application, so as to display the default sub-application page corresponding to the sub-application to which the user is to return. For example, the parent application can restart (or open) the sub-application and display the homepage of the sub-application.

[0082] In this embodiment, while the sub-application to be returned to is still running in the background, it can be switched to the foreground to quickly return to the page displayed when the sub-application was navigated to, allowing the user to continue operating on that page and improving the application's convenience. Furthermore, if the sub-application to be returned to has finished running, the default sub-application page is directly returned from the parent application, avoiding the time-consuming manual switching and improving the application's efficiency.

[0083] In the above embodiments, a method for handling the return of a sub-application after a jump is provided, so that when intending to return to a sub-application that has been used, the return can be made directly in the parent application without having to exit the currently used application and then start the application to which the intention is to return, which would cause time consumption and improve the efficiency of application use.

[0084] Figure 4 illustrates a schematic diagram of sub-application return in one embodiment. Referring to Figure 4, the schematic diagram includes a return operation entry 400, a currently displayed sub-application page 401, a sub-application page 402 displayed when the target sub-application is redirected, and a default sub-application page 403 of the target sub-application. After the terminal detects a trigger operation on the return operation entry 400, it determines the target sub-application through the parent application. When the parent application runs in the background, the sub-application page 402 displayed when the target sub-application is redirected is overlaid on the currently displayed sub-application page 401. When the terminal determines through the parent application that the target sub-application has finished running, the default sub-application page 403 of the target sub-application is overlaid on the currently displayed sub-application page 401.

[0085] In one embodiment, the sub-application includes a native plugin sub-application. When the obtained sub-application identifier exists in the jump path, moving the obtained sub-application identifier to the end of the jump path includes: when the obtained sub-application identifier exists in the jump path, determining consecutive native plugin sub-application identifiers in the jump path that are adjacent to and follow the obtained sub-application identifier; moving the obtained sub-application identifier to the end of the jump path; and deleting consecutive native plugin sub-application identifiers in the jump path.

[0086] Native plugin sub-applications are developed by the developers of the parent application to implement the plugin functionality of the parent application. Examples include nearby entry sub-applications or scan sub-applications. When a native plugin sub-application runs within the parent application, it and the parent application can be considered as a single entity. Similarly, when navigating from a sub-application to a native plugin sub-application, the native plugin sub-application and the intended sub-application can also be considered as a single entity.

[0087] Specifically, the terminal can obtain the jump path used to record the jump relationship of sub-applications through the parent application, traverse the sub-application identifiers in the obtained jump path, and compare the traversed sub-application identifier with the obtained sub-application identifier. When the parent application determines that the traversed sub-application identifier is the same as the obtained sub-application identifier, it checks whether the next sub-application identifier of the traversed sub-application identifier is a native plugin sub-application identifier.

[0088] If the parent application determines that the next sub-application identifier encountered in the jump path is a native plugin sub-application identifier, it determines all consecutive native plugin sub-application identifiers starting from that identifier, moves the obtained sub-application identifier to the end of the jump path, and deletes the consecutive native plugin sub-application identifiers from the jump path. If the parent application determines that the next sub-application identifier encountered in the jump path is not a native plugin sub-application identifier, it directly moves the obtained sub-application identifier to the end of the jump path.

[0089] In other words, native plugin sub-applications are used to provide the functionality of the parent application or the sub-application. When it is necessary to move the position of the sub-application identifier, the adjacent and consecutive native plugin sub-application identifiers after the sub-application identifier are deleted at the same time.

[0090] For example, suppose the terminal obtains the jump path "A→B→K1→K2→C" through the parent application, where K1 and K2 are the identifiers of native plugin sub-applications. If the current intention is to jump from the sub-application corresponding to C to the sub-application corresponding to B, then B exists in "A→B→K1→K2→C", and the next sub-application identifier of B is K1, which is the identifier of the native plugin sub-application. Then, the consecutive native plugin sub-application identifiers "K1→K2" after B are determined, B is moved to the end of "A→B→K1→K2→C", and "K1→K2" is deleted, resulting in "A→C→B".

[0091] If the current intention is to jump from the sub-application corresponding to C to the native plugin sub-application corresponding to K1, then K1 exists in "A→B→K1→K2→C", and the next sub-application identifier of K1 is K2, which is the native plugin sub-application identifier. Then, determine the consecutive native plugin sub-application identifier "K2" after K1, move K1 to the end of "A→B→K1→K2→C", and delete "K2" to get "A→B→C→K1".

[0092] If the current intention is to jump from the sub-application corresponding to C to the native plugin sub-application corresponding to K2, then K2 exists in "A→B→K1→K2→C". The next sub-application of K2 is identified as C, which is not the native plugin sub-application. K2 is then moved directly to the end of "A→B→K1→K2→C", resulting in "A→B→K1→C→K2".

[0093] In this embodiment, a native plugin sub-application that can be used as a component of a sub-application is provided. This allows users to achieve a user experience that is essentially the same as using the sub-application directly when switching from the sub-application. This avoids the process of developing sub-applications and improves the efficiency of sub-application implementation.

[0094] In one embodiment, the sub-application further includes a third-party sub-application. The application processing method further includes: detecting a close command through the sub-application to which the currently displayed sub-application page belongs; when a close command is detected and a native plugin sub-application identifier (i.e., the first native plugin sub-application identifier) ​​exists before the first third-party sub-application identifier in the jump path, then returning the native plugin sub-application corresponding to the native plugin sub-application identifier; when a close command is detected and no native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, then returning to the parent application.

[0095] Among them, third-party sub-applications are sub-applications developed by third-party service providers registered on the open service platform corresponding to the parent application. The close command is used to close the sub-application and return to the parent application or the native plugin sub-application.

[0096] For example, the parent application is WeChat, and the third-party sub-applications include shared bicycles, XXXX shopping, etc. Within WeChat, users can scan a QR code, search for the name of the third-party sub-application (such as Mobike), click on messages or business cards shared by other users, etc., to download and run the third-party sub-application, and then use the services provided by the third-party sub-application. The third-party sub-application is seamlessly integrated into the parent application, becoming part of the parent application, giving users a native experience, and the third-party sub-application significantly expands the functionality of the parent application. For example, WeChat allows users to use shared bicycles through Mobike, and XXXX shopping allows users to make purchases, etc.

[0097] In one embodiment, the terminal can detect or listen to events triggered within the currently displayed sub-application page, through the sub-application to which the currently displayed sub-application page belongs. These events trigger the closure of the sub-application, returning the user to the parent application or a native plugin sub-application. The event can be a trigger action on an icon (e.g., control 500 in Figure 5) or a virtual button. When an event triggering the closure of the sub-application is detected or listened to, the jump path becomes invalid. For example, if the jump path is A→B→C, and sub-application C is currently displayed, but the user operates control 500 in Figure 5 (i.e., closes sub-application C), the jump path A→B→C becomes invalid, and the user returns to the parent application.

[0098] Specifically, after the terminal detects or listens for a close command through the sub-application to which the currently displayed sub-application page belongs, it queries the parent application to see if a native plugin sub-application identifier exists before the first third-party sub-application identifier in the redirection path. If a native plugin sub-application identifier exists before the first third-party sub-application identifier in the redirection path, the native plugin sub-application corresponding to that identifier is returned. If no native plugin sub-application identifier exists before the first third-party sub-application identifier in the redirection path, the parent application is returned.

[0099] In one embodiment, returning the native plugin sub-application corresponding to the native plugin sub-application identifier includes: when there are more than one native plugin sub-application identifiers existing before the first third-party sub-application identifier in the jump path, obtaining the native plugin sub-application identifier adjacent to and preceding the first third-party sub-application identifier (i.e., the second native plugin sub-application identifier); determining the native plugin sub-application page displayed when jumping to the native plugin sub-application corresponding to the obtained native plugin sub-application identifier; and displaying the determined native plugin sub-application page.

[0100] Specifically, when the terminal, through the parent application, finds a native plugin sub-application identifier preceding the first third-party sub-application identifier in the redirection path, it determines whether the number of native plugin sub-application identifiers preceding the first third-party sub-application identifier in the redirection path is greater than one. If the terminal determines through the parent application that the number of native plugin sub-application identifiers is only one, it displays the native plugin sub-application page corresponding to that unique identifier during the redirection.

[0101] If the terminal determines through the parent application that there are more than one native plugin sub-application identifier, then it obtains the native plugin sub-application identifier that is adjacent to and precedes the first third-party sub-application identifier; determines the native plugin sub-application page to be displayed when the obtained native plugin sub-application identifier is navigated to; and displays the determined native plugin sub-application page.

[0102] In this embodiment, since the native plugin sub-application is used to provide the functionality of the parent application and is regarded as a whole with the parent application, when intending to close the running third-party sub-application, it directly returns to the parent application or the native plugin sub-application, without the need for indirect control through the third-party sub-application, thus improving the efficiency of application usage.

[0103] In the above embodiments, when switching between sub-applications and intending to close a running third-party sub-application, it is only necessary to trigger a close command to directly return to the parent application or the native plugin sub-application, avoiding the time-consuming process of closing each third-party sub-application one by one and improving the efficiency of application usage.

[0104] Figure 5 illustrates a schematic diagram of a sub-application being closed in one embodiment. Referring to Figure 5, the schematic diagram includes a closure trigger entry 500, the currently displayed sub-application page 501, a native plugin sub-application identifier adjacent to and preceding the first third-party sub-application identifier in the jump path, the native plugin sub-application page 502 displayed when the corresponding native plugin sub-application jumps, and the parent application page 503 displayed when the parent application runs the sub-application.

[0105] The terminal is currently displaying sub-application page 501. Upon detecting a trigger operation targeting the close trigger entry 500, if the parent application detects that a native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, it returns, according to the close instruction, the native plugin sub-application page 502 displayed when the corresponding native plugin sub-application is jumped to, the one adjacent to and preceding the first third-party sub-application identifier in the jump path. If the parent application detects that no native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, it returns to the parent application page 503 displayed when the parent application is running the sub-application.

[0106] In one embodiment, passing page data corresponding to a sub-application identifier to a sub-application that corresponds to the sub-application identifier and is run by the parent application includes: switching to a parent application page used to trigger the sub-application jump, wherein the parent application page is a page displayed by the parent application; triggering the acquisition of page data corresponding to the sub-application identifier through the parent application page; and passing the page data to the sub-application that corresponds to the sub-application identifier and is run by the parent application.

[0107] Specifically, the parent application page is used to trigger navigation to child applications. That is, when intending to navigate from one child application to another, it is necessary to first switch to the parent application page, and then trigger the retrieval of page data corresponding to the child application's identifier through that parent application page. The page data is then passed to the child application corresponding to the child application's identifier and run by the parent application.

[0108] The parent application page used to trigger the jump to a sub-application can be a unified parent application page. This unified parent application page can trigger the jump to any sub-application. Alternatively, the parent application page used to trigger the jump to a sub-application can be a parent application page that corresponds one-to-one with each sub-application. Each sub-application has a corresponding parent application page used to launch that sub-application.

[0109] In this embodiment, a new method for sub-application navigation is provided by switching to the parent application page that triggers the sub-application navigation.

[0110] Figure 6 illustrates a schematic diagram of sub-application navigation in one embodiment. Referring to Figure 6, the schematic diagram includes a currently displayed sub-application page 601, a parent application page 602 used to trigger the sub-application navigation, and a sub-application page 603 corresponding to the sub-application to which the user is to navigate. The terminal switches from the currently displayed sub-application page 601 to the parent application page 602 used to trigger the sub-application navigation, and then triggers navigation to the sub-application page 603 corresponding to the sub-application to which the user is to navigate, thus realizing the sub-application navigation.

[0111] In one embodiment, after S204, the application processing method further includes: obtaining the parent application page identifier (i.e., the first parent application page) corresponding to the switched parent application page (i.e., the first parent application page), and a jump path for recording the jump relationship of the sub-applications; when the obtained sub-application identifier exists in the jump path, deleting the parent application page identifier (i.e., the second parent application page identifier) ​​that is adjacent to and follows the obtained sub-application identifier in the jump path; adding the obtained parent application page identifier to the end of the jump path; and moving the obtained sub-application identifier in the jump path after the added parent application page identifier.

[0112] The jump path includes the identifiers of the sub-applications and / or the page identifiers of the parent application, arranged in the order of the sub-application jumps. It records the jump relationship of the sub-applications and reflects the jump method of the sub-applications. For example, the jump path that records the jump relationship of "jumping from sub-application A to sub-application C by switching to the parent application page M" is: A→M→C.

[0113] Specifically, the terminal can obtain the jump path used to record the jump relationship of sub-applications through the parent application, traverse the sub-application identifiers in the obtained jump path, and compare the traversed sub-application identifier with the obtained sub-application identifier. When the parent application determines that the traversed sub-application identifier is the same as the obtained sub-application identifier, it deletes the parent application page identifier that is adjacent to the traversed sub-application identifier, adds the corresponding parent application page identifier of the switched parent application page to the end of the jump path, and then moves the traversed sub-application identifier after the added parent application page identifier.

[0114] When the parent application determines that none of the child application identifiers it traverses are the same as the obtained child application identifiers, it directly adds the corresponding parent application page identifier of the parent application page to which it switches, as well as the obtained child application identifier, to the end of the jump path in sequence.

[0115] For example, suppose the terminal obtains the navigation path "A→M1→B→C" through the parent application. If the current intention is to navigate from the sub-application corresponding to C to the sub-application corresponding to A through the parent application page M2, and A exists in "A→M1→B→C", then delete the parent application page M1 that is adjacent to A, add M2 to the end of "A→B→C", and move A after M2, resulting in "B→C→M2→A".

[0116] In this embodiment, when navigating between sub-applications within the environment provided by the parent application, the sub-application navigation relationship reflecting the navigation method of the sub-applications is recorded, thereby allowing for a step-by-step return to each visited sub-application or parent application page.

[0117] In other embodiments, when a sub-application switches to the parent application's page and then triggers a jump to another sub-application, both the parent application's page identifier and the sub-application's identifier are recorded in the jump path. When the sub-application returns via the parent application's return interface, no data is transferred. If the sub-application to which the current application needs to return, as determined by the jump path, is not the original sub-application from which the current application needs to return, then no data is transferred when the sub-application returns via the parent application's return interface.

[0118] Figure 7 is a flowchart illustrating the application processing method in a specific embodiment. Referring to Figure 7, the application processing method specifically includes the following steps:

[0119] S702 displays the sub-application page of the child application run by the parent application. The sub-applications include native plugin sub-applications and third-party sub-applications.

[0120] S704: Obtain the corresponding sub-application identifier (such as APP ID) of the sub-application to which the user is to be redirected.

[0121] S706, detect the sub-application's redirection method; if the sub-application redirects by calling an interface provided by the parent application (such as launch JSAPI), proceed to step S708; if the sub-application redirects by being triggered through the parent application's page, proceed to step S722.

[0122] S708, the page data corresponding to the sub-application identifier is passed to the sub-application that corresponds to the sub-application identifier and is run by the parent application.

[0123] S710, obtain the jump path used to record the jump relationship of sub-applications.

[0124] S712, check if the obtained sub-application identifier exists in the jump path; if yes, jump to step S714; if no, jump to step S720.

[0125] S714, detect whether there is a native plugin sub-application that is adjacent to the obtained sub-application identifier; if yes, proceed to step S716; if no, proceed to step S718.

[0126] S716, determine the consecutive native plugin sub-application identifiers in the jump path that are adjacent to and follow the obtained sub-application identifier; move the obtained sub-application identifier to the end of the jump path, and delete the consecutive native plugin sub-application identifiers in the jump path.

[0127] S718 moves the acquired sub-application identifier to the end of the jump path.

[0128] S720 adds the obtained sub-application identifier to the end of the jump path.

[0129] S722, switch to the parent application page used to trigger the child application jump; through the parent application page, trigger the acquisition of page data corresponding to the child application identifier; pass the page data to the child application corresponding to the child application identifier and run by the parent application.

[0130] S724, obtain the parent application page identifier corresponding to the parent application page to which the user switches, and the jump path used to record the jump relationship of the child application.

[0131] S726, check if the obtained sub-application identifier exists in the jump path; if yes, jump to step S728; if no, jump to step S730.

[0132] S728, delete the parent application page identifier that is adjacent to and follows the obtained sub-application identifier in the jump path; add the obtained parent application page identifier to the end of the jump path; move the obtained sub-application identifier in the jump path after the added parent application page identifier.

[0133] S730 adds the obtained parent application page identifier and child application identifier to the end of the jump path in sequence.

[0134] S732 generates a sub-application page that is overlaid on the already displayed sub-application page based on the page data, using the sub-application corresponding to the sub-application identifier.

[0135] S734, obtain a return instruction through the sub-application to which the currently displayed sub-application page belongs; in response to the return instruction, determine the corresponding sub-application identifier of the currently displayed sub-application page; in the jump path, find the sub-application identifier that is adjacent to the determined sub-application identifier and located before the determined sub-application identifier.

[0136] S736, detect the running status of the sub-application corresponding to the found sub-application identifier; if the sub-application corresponding to the found sub-application identifier is running from the background state of the parent application, then jump to step S738; if the sub-application corresponding to the found sub-application identifier has ended running, then jump to step S740.

[0137] S738, returns the sub-application page displayed when the sub-application corresponding to the found sub-application identifier is redirected.

[0138] S740, returns the default sub-application page corresponding to the found sub-application identifier.

[0139] S742 detects a close command by examining the sub-application to which the currently displayed sub-application page belongs.

[0140] S744, when a close command is detected, check whether there is a native plugin sub-application identifier before the first third-party sub-application identifier in the jump path; if yes, jump to step S746; if no, jump to step S752.

[0141] S746, check if the number of native plugin sub-application identifiers that exist before the first third-party sub-application identifier in the jump path is more than one; if yes, jump to step S748; if no, jump to step S750.

[0142] S748, obtain the native plugin sub-application identifier that is adjacent to and precedes the first third-party sub-application identifier; determine the native plugin sub-application page displayed when the native plugin sub-application corresponding to the obtained native plugin sub-application identifier is redirected; display the determined native plugin sub-application page.

[0143] S750, returns the native plugin sub-application corresponding to the native plugin sub-application identifier.

[0144] S752, return to the parent application.

[0145] In this embodiment, a parent application runs on the operating system, and child applications are run by the parent application, displaying the child application's page. When a child application jump is needed, the parent application only needs to obtain the corresponding child application identifier of the child application to which it wants to jump, and then pass the page data corresponding to that identifier to the child application running by the parent application. The child application then generates a new child application page that overlays the already displayed child application page based on the page data, automatically achieving the child application jump. This avoids the time-consuming process of exiting the currently used application and restarting the intended application, improving application efficiency.

[0146] Furthermore, it provides a method for returning after a jump to a sub-application, allowing users to directly return from the parent application when intending to return to an already used sub-application. This avoids the time-consuming process of exiting the currently used application and then restarting the intended application, thus improving application efficiency. When intending to close a running third-party sub-application after a jump between sub-applications, users only need to trigger a close command to directly return to the parent application or the native plugin sub-application, avoiding the time-consuming process of closing each third-party sub-application individually, further improving application efficiency.

[0147] As shown in FIG8, in one embodiment, an application processing device 800 is provided. Referring to FIG8, the application processing device 800 includes a parent application 810.

[0148] The parent application 810 is used to display the sub-application page of the running sub-application; obtain the corresponding sub-application identifier of the sub-application to which the user is to jump; pass the page data corresponding to the sub-application identifier to the sub-application running by the parent application that corresponds to the sub-application identifier; and generate a sub-application page that is overlaid on the already displayed sub-application page based on the page data from the sub-application that corresponds to the sub-application identifier.

[0149] The aforementioned application processing device 800 runs a parent application on its operating system, and child applications can be run by the parent application, displaying the child application's page. When a child application jump is needed, the parent application only needs to obtain the corresponding child application identifier of the child application to which it wants to jump, and then pass the page data corresponding to that child application identifier to the child application running by the parent application. The child application then generates a child application page that overlays the already displayed child application page based on the page data, automatically realizing the child application jump. This avoids the time-consuming process of exiting the currently used application and restarting the intended application, improving application efficiency.

[0150] In one embodiment, the parent application 810 is further configured to obtain a jump path for recording the jump relationship of the sub-applications; when the obtained sub-application identifier exists in the jump path, the obtained sub-application identifier is moved to the end of the jump path; when the obtained sub-application identifier does not exist in the jump path, the obtained sub-application identifier is added to the end of the jump path.

[0151] In this embodiment, when navigating between sub-applications within the environment provided by the parent application, the navigation relationships between the sub-applications are recorded, allowing for a step-by-step return to each visited sub-application.

[0152] In one embodiment, the parent application 810 is further configured to obtain a return instruction through the sub-application to which the currently displayed sub-application page belongs; in response to the return instruction, determine the sub-application identifier corresponding to the currently displayed sub-application page; in the jump path, find the sub-application identifier that is adjacent to the determined sub-application identifier and located before the determined sub-application identifier; and return the sub-application page corresponding to the found sub-application identifier.

[0153] In this embodiment, a method for returning after a jump is provided, so that when intending to return to a used sub-application, the return can be made directly in the parent application without having to exit the currently used application and then restart the application to which the intention is to return, thus improving the efficiency of application usage.

[0154] In one embodiment, the parent application 810 is further configured to, when the sub-application corresponding to the found sub-application identifier is running from the parent application in the background state, return the sub-application page displayed when the sub-application corresponding to the found sub-application identifier is redirected; and when the sub-application corresponding to the found sub-application identifier has finished running, return the default sub-application page corresponding to the found sub-application identifier.

[0155] In this embodiment, while the sub-application to be returned to is still running in the background, it can be switched to the foreground to quickly return to the page displayed when the sub-application was navigated to, allowing the user to continue operating on that page and improving the application's convenience. Furthermore, if the sub-application to be returned to has finished running, the default sub-application page is directly returned from the parent application, avoiding the time-consuming manual switching and improving the application's efficiency.

[0156] In one embodiment, the sub-application includes a native plugin sub-application. The parent application 810 is further configured to, when the acquired sub-application identifier exists in the jump path, determine the consecutive native plugin sub-application identifiers in the jump path that are adjacent to and follow the acquired sub-application identifier; move the acquired sub-application identifier to the end of the jump path; and delete the consecutive native plugin sub-application identifiers in the jump path.

[0157] In this embodiment, a native plugin sub-application that can be used as a component of a sub-application is provided. This allows users to achieve a user experience that is essentially the same as using the sub-application directly when switching from the sub-application to the native plugin sub-application, thus avoiding the process of developing sub-applications and improving the efficiency of sub-application implementation.

[0158] In one embodiment, the sub-application further includes a third-party sub-application. The parent application 810 is also configured to detect a close command through the sub-application to which the currently displayed sub-application page belongs; when a close command is detected and a native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, the parent application is returned; when a close command is detected and no native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, the parent application is returned.

[0159] In this embodiment, when attempting to close a running third-party sub-application after completing a jump between sub-applications, the user only needs to trigger a close command to directly return to the parent application or the native plugin sub-application. This avoids the time-consuming process of closing each third-party sub-application individually and improves application efficiency.

[0160] In one embodiment, the parent application 810 is further configured to: when there are more than one native plugin sub-application identifiers existing before the first third-party sub-application identifier in the jump path, obtain the native plugin sub-application identifier that is adjacent to and precedes the first third-party sub-application identifier; determine the native plugin sub-application page displayed by the native plugin sub-application corresponding to the obtained native plugin sub-application identifier during the jump; and display the determined native plugin sub-application page.

[0161] In this embodiment, since the native plugin sub-application is used to provide the functionality of the parent application and is regarded as a whole with the parent application, when intending to close the running third-party sub-application, it directly returns to the parent application or the native plugin sub-application, without the need for indirect control through the third-party sub-application, thus improving the efficiency of application usage.

[0162] In one embodiment, the parent application 810 is further configured to switch to a parent application page for triggering a jump to a sub-application; trigger the acquisition of page data corresponding to the sub-application identifier through the parent application page; and pass the page data to the sub-application corresponding to the sub-application identifier and run by the parent application.

[0163] In this embodiment, a new method for sub-application navigation is provided by switching to the parent application page that triggers the sub-application navigation.

[0164] In one embodiment, the parent application 810 is further configured to obtain the parent application page identifier corresponding to the parent application page to which the application is switched, and a jump path for recording the jump relationship of the sub-applications; when the obtained sub-application identifier exists in the jump path, the parent application page identifier that is adjacent to the obtained sub-application identifier and located after the obtained sub-application identifier in the jump path is deleted; the obtained parent application page identifier is added to the end of the jump path; and the obtained sub-application identifier in the jump path is moved after the added parent application page identifier.

[0165] In this embodiment, when navigating between sub-applications within the environment provided by the parent application, the sub-application navigation relationship reflecting the navigation method of the sub-applications is recorded, thereby allowing for a step-by-step return to each visited sub-application or parent application page.

[0166] As shown in Figure 9, in one embodiment, a module structure diagram of a parent application 810 is provided. Referring to Figure 9, the parent application 810 includes: a display module 801, an acquisition module 802, a transmission module 803, and a jump module 804.

[0167] Display module 801 is used to display the sub-application page of the running sub-application.

[0168] The acquisition module 802 is used to obtain the corresponding sub-application identifier of the sub-application to which the user is to be redirected.

[0169] The transmission module 803 is used to transmit the page data corresponding to the sub-application identifier to the sub-application that corresponds to the sub-application identifier and is run by the parent application.

[0170] The jump module 804 is used to generate a sub-application page that is overlaid on the already displayed sub-application page based on the page data, according to the sub-application corresponding to the sub-application identifier.

[0171] The aforementioned parent application 810 allows child applications to be run by the parent application, displaying the sub-application pages belonging to those child applications. When a sub-application jump is needed, the parent application only needs to obtain the corresponding sub-application identifier of the sub-application to which it wants to jump. It can then pass the page data corresponding to that identifier to the corresponding sub-application run by the parent application. The parent application, based on the page data, can then generate a sub-application page that overlays the already displayed sub-application page, automatically achieving the sub-application jump. This avoids the time-consuming process of exiting the currently used application and restarting the intended application, improving application efficiency.

[0172] In one embodiment, the acquisition module 902 is further configured to acquire a jump path for recording the jump relationship of sub-applications; when the acquired sub-application identifier exists in the jump path, the acquired sub-application identifier is moved to the end of the jump path; when the acquired sub-application identifier does not exist in the jump path, the acquired sub-application identifier is added to the end of the jump path.

[0173] In this embodiment, when navigating between sub-applications within the parent application, the navigation relationships between the sub-applications are recorded, allowing for a step-by-step return to each visited sub-application.

[0174] As shown in Figure 10, in one embodiment, the parent application 810 further includes an instruction processing module 805.

[0175] The instruction processing module 805 is used to obtain a return instruction based on the sub-application to which the currently displayed sub-application page belongs; in response to the return instruction, determine the corresponding sub-application identifier of the currently displayed sub-application page; in the jump path, find the sub-application identifier that is adjacent to the determined sub-application identifier and located before the determined sub-application identifier; and return the sub-application page corresponding to the found sub-application identifier.

[0176] In this embodiment, a method for returning after a jump is provided, so that when intending to return to a used sub-application, the return can be made directly in the parent application without having to exit the currently used application and then restart the application to which the intention is to return, thus improving the efficiency of application usage.

[0177] In one embodiment, the instruction processing module 805 is further configured to, when the sub-application corresponding to the found sub-application identifier is running from the parent application in the background state, return the sub-application page displayed when the jump occurs in the sub-application corresponding to the found sub-application identifier; and when the sub-application corresponding to the found sub-application identifier has finished running, return the default sub-application page corresponding to the found sub-application identifier.

[0178] In this embodiment, while the sub-application to be returned to is still running in the background, it can be switched to the foreground to quickly return to the page displayed when the sub-application was navigated to, allowing the user to continue operating on that page and improving the application's convenience. Furthermore, if the sub-application to be returned to has finished running, the default sub-application page is directly returned from the parent application, avoiding the time-consuming manual switching and improving the application's efficiency.

[0179] In one embodiment, the sub-application includes a native plugin sub-application. The acquisition module 802 is further configured to, when the acquired sub-application identifier exists in the jump path, determine the consecutive native plugin sub-application identifiers in the jump path that are adjacent to and follow the acquired sub-application identifier; move the acquired sub-application identifier to the end of the jump path; and delete the consecutive native plugin sub-application identifiers in the jump path.

[0180] In this embodiment, a native plugin sub-application that can be used as a component of a sub-application is provided. This allows users to achieve a user experience that is essentially the same as using the sub-application directly when switching from the sub-application to the native plugin sub-application, thus avoiding the process of developing sub-applications and improving the efficiency of sub-application implementation.

[0181] In one embodiment, the sub-application further includes a third-party sub-application. The instruction processing module 805 is further configured to detect a close instruction by identifying the sub-application to which the currently displayed sub-application page belongs; when a close instruction is detected and a native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, the native plugin sub-application corresponding to the native plugin sub-application identifier is returned; when a close instruction is detected and no native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, the parent application is returned.

[0182] In this embodiment, when attempting to close a running third-party sub-application after completing a jump between sub-applications, the user only needs to trigger a close command to directly return to the parent application or the native plugin sub-application. This avoids the time-consuming process of closing each third-party sub-application individually and improves application efficiency.

[0183] In one embodiment, the instruction processing module 805 is further configured to: when the number of native plugin sub-application identifiers preceding the first third-party sub-application identifier in the jump path is greater than one, obtain the native plugin sub-application identifier that is adjacent to and precedes the first third-party sub-application identifier; determine the native plugin sub-application page displayed when the obtained native plugin sub-application identifier is jumped; and display the determined native plugin sub-application page.

[0184] In this embodiment, since the native plugin sub-application is used to provide the functionality of the parent application and is regarded as a whole with the parent application, when intending to close the running third-party sub-application, it directly returns to the parent application or the native plugin sub-application, without the need for indirect control through the third-party sub-application, thus improving the efficiency of application usage.

[0185] In one embodiment, the transmission module 803 is further configured to switch to the parent application page used to trigger the jump of the sub-application; trigger the acquisition of page data corresponding to the sub-application identifier through the parent application page; and transmit the page data to the sub-application corresponding to the sub-application identifier and run by the parent application.

[0186] In this embodiment, a new method for sub-application navigation is provided by switching to the parent application page that triggers the sub-application navigation.

[0187] In one embodiment, the acquisition module 802 is further configured to acquire the parent application page identifier corresponding to the parent application page to which the user switches, and the jump path for recording the jump relationship of the sub-applications; when the acquired sub-application identifier exists in the jump path, the parent application page identifier that is adjacent to the acquired sub-application identifier and located after the acquired sub-application identifier in the jump path is deleted; the acquired parent application page identifier is added to the end of the jump path; and the acquired sub-application identifier in the jump path is moved after the added parent application page identifier.

[0188] In this embodiment, when navigating between sub-applications within the environment provided by the parent application, the sub-application navigation relationship reflecting the navigation method of the sub-applications is recorded, thereby allowing for a step-by-step return to each visited sub-application or parent application page.

[0189] Figure 11 illustrates the internal structure of a computer device in one embodiment. Specifically, this computer device may be the terminal 110 in Figure 1. As shown in Figure 11, the computer device 1100 includes a processor 1101, a non-volatile storage medium 1102, internal memory 1103, a network interface 1104, and a display screen 1105 connected via a system bus. The non-volatile storage medium 1102 of the computer device 1100 may store an operating system 1106 and computer-readable instructions 1107. When the computer-readable instructions 1107 are executed, they cause the processor 1101 to execute an application processing method. The processor 1101 provides computing and control capabilities to support the operation of the entire computer device. The internal memory 1103 may store the computer-readable instructions 1107. When the computer-readable instructions 1107 are executed by the processor 1101, they cause the processor 1101 to execute an application processing method. The network interface 1104 is used for network communication with a server, such as sending a cooperative operation authorization request to the server and receiving an authorization response from the server. The display screen of computer device 1100 can be a liquid crystal display screen or an e-ink display screen, etc. Computer device 1100 can be a mobile phone, tablet computer, personal digital assistant, or wearable device, etc. Those skilled in the art will understand that the structure shown in Figure 11 is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than shown in the figure, or combine certain components, or have different component arrangements.

[0190] In one embodiment, the application processing apparatus provided in this application can be implemented as a computer program that can run on a computer device 1100 as shown in FIG. 11. The non-volatile storage medium of the computer device can store various program modules constituting the application processing apparatus, such as the parent application 810 shown in FIG. 8. Each program module includes computer-readable instructions that are used to cause the computer device to execute the steps in the application processing methods of the various embodiments of this application described in this specification. For example, the computer device can display a sub-application page of a running sub-application through the parent application 810 in the application processing apparatus 800 shown in FIG. 8; obtain the corresponding sub-application identifier of the sub-application to which the user is to jump; transfer the page data corresponding to the sub-application identifier to the sub-application running by the parent application and corresponding to the sub-application identifier; and generate a sub-application page to be displayed on top of the already displayed sub-application page based on the page data through the sub-application corresponding to the sub-application identifier.

[0191] In one embodiment, a computer-readable storage medium is provided, which stores computer-readable instructions that, when executed by a processor, cause the processor to perform the following steps: displaying a sub-application page of a sub-application run by a parent application; obtaining, through the sub-application, a sub-application identifier corresponding to the sub-application to which the user is to jump; transferring page data corresponding to the sub-application identifier to the sub-application running by the parent application corresponding to the sub-application identifier; and generating a sub-application page to be displayed over the already displayed sub-application page, based on the page data, through the sub-application corresponding to the sub-application identifier.

[0192] In one embodiment, the computer-readable instructions cause the processor to execute the following steps after obtaining the corresponding sub-application identifier of the sub-application to which it is to jump: obtaining a jump path for recording the jump relationship of the sub-applications; moving the obtained sub-application identifier to the end of the jump path when the obtained sub-application identifier exists in the jump path; and adding the obtained sub-application identifier to the end of the jump path when the obtained sub-application identifier does not exist in the jump path.

[0193] In one embodiment, the computer-readable instructions further cause the processor to perform the following steps: obtain a return instruction by way of the sub-application to which the currently displayed sub-application page belongs; determine the sub-application identifier corresponding to the currently displayed sub-application page in response to the return instruction; locate, in the jump path, a sub-application identifier that is adjacent to and precedes the determined sub-application identifier; and return to the sub-application page corresponding to the located sub-application identifier.

[0194] In one embodiment, returning the sub-application page corresponding to the found sub-application identifier includes: when the sub-application corresponding to the found sub-application identifier is running from the parent application in the background state, returning the sub-application page displayed when the sub-application corresponding to the found sub-application identifier is redirected; when the sub-application corresponding to the found sub-application identifier has finished running, returning the default sub-application page corresponding to the found sub-application identifier.

[0195] In one embodiment, the sub-application includes a native plugin sub-application. When the obtained sub-application identifier exists in the jump path, moving the obtained sub-application identifier to the end of the jump path includes: when the obtained sub-application identifier exists in the jump path, determining consecutive native plugin sub-application identifiers in the jump path that are adjacent to and follow the obtained sub-application identifier; moving the obtained sub-application identifier to the end of the jump path; and deleting consecutive native plugin sub-application identifiers in the jump path.

[0196] In one embodiment, the sub-application further includes a third-party sub-application. The computer-readable instructions also cause the processor to perform the following steps: detect a close instruction via the sub-application to which the currently displayed sub-application page belongs; when a close instruction is detected and a native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, return the native plugin sub-application corresponding to the native plugin sub-application identifier; when a close instruction is detected and no native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, return to the parent application.

[0197] In one embodiment, returning the native plugin sub-application corresponding to the native plugin sub-application identifier includes: when there are more than one native plugin sub-application identifiers existing before the first third-party sub-application identifier in the jump path, obtaining the native plugin sub-application identifier that is adjacent to and precedes the first third-party sub-application identifier; determining the native plugin sub-application page displayed when the obtained native plugin sub-application identifier is jumped; and displaying the determined native plugin sub-application page.

[0198] In one embodiment, passing page data corresponding to a sub-application identifier to a sub-application that corresponds to the sub-application identifier and is run by the parent application includes: switching to the parent application page used to trigger the sub-application jump; triggering the acquisition of page data corresponding to the sub-application identifier through the parent application page; and passing the page data to the sub-application that corresponds to the sub-application identifier and is run by the parent application.

[0199] In one embodiment, the computer-readable instructions cause the processor to execute the following steps after obtaining the sub-application identifier corresponding to the sub-application to which it is to jump: obtaining the parent application page identifier corresponding to the parent application page to which it is switched, and a jump path for recording the sub-application jump relationship; when the obtained sub-application identifier exists in the jump path, deleting the parent application page identifier in the jump path that is adjacent to and follows the obtained sub-application identifier; adding the obtained parent application page identifier to the end of the jump path; and moving the obtained sub-application identifier in the jump path after the added parent application page identifier.

[0200] In the aforementioned storage medium, the operating system runs a parent application, and child applications are run by the parent application, displaying the child application's page. When a child application jump is needed, the parent application only needs to obtain the corresponding child application identifier from the child application to which it wants to jump. It then passes the page data corresponding to that identifier to the child application running by the parent application. The child application then generates a page that overlays the already displayed child application page based on the page data, automatically achieving the child application jump. This avoids the time-consuming process of exiting the currently used application and restarting the intended application, improving application efficiency.

[0201] In one embodiment, a computer device is provided, including a memory and a processor. The memory stores computer-readable instructions, which, when executed by the processor, cause the processor to perform the following steps: displaying a sub-application page of a sub-application run by a parent application; obtaining, through the sub-application, a sub-application identifier corresponding to the sub-application to which the user is to navigate; transferring page data corresponding to the sub-application identifier to the sub-application running by the parent application corresponding to the sub-application identifier; and generating a sub-application page to be displayed over the already displayed sub-application page, based on the page data, through the sub-application corresponding to the sub-application identifier.

[0202] In one embodiment, the computer-readable instructions cause the processor to execute the following steps after obtaining the corresponding sub-application identifier of the sub-application to which it is to jump: obtaining a jump path for recording the jump relationship of the sub-applications; moving the obtained sub-application identifier to the end of the jump path when the obtained sub-application identifier exists in the jump path; and adding the obtained sub-application identifier to the end of the jump path when the obtained sub-application identifier does not exist in the jump path.

[0203] In one embodiment, the computer-readable instructions further cause the processor to perform the following steps: obtain a return instruction by way of the sub-application to which the currently displayed sub-application page belongs; determine the sub-application identifier corresponding to the currently displayed sub-application page in response to the return instruction; locate, in the jump path, a sub-application identifier that is adjacent to and precedes the determined sub-application identifier; and return to the sub-application page corresponding to the located sub-application identifier.

[0204] In one embodiment, returning the sub-application page corresponding to the found sub-application identifier includes: when the sub-application corresponding to the found sub-application identifier is running from the parent application in the background state, returning the sub-application page displayed when the sub-application corresponding to the found sub-application identifier is redirected; when the sub-application corresponding to the found sub-application identifier has finished running, returning the default sub-application page corresponding to the found sub-application identifier.

[0205] In one embodiment, the sub-application includes a native plugin sub-application. When the obtained sub-application identifier exists in the jump path, moving the obtained sub-application identifier to the end of the jump path includes: when the obtained sub-application identifier exists in the jump path, determining consecutive native plugin sub-application identifiers in the jump path that are adjacent to and follow the obtained sub-application identifier; moving the obtained sub-application identifier to the end of the jump path; and deleting consecutive native plugin sub-application identifiers in the jump path.

[0206] In one embodiment, the sub-application further includes a third-party sub-application. The computer-readable instructions also cause the processor to perform the following steps: detect a close instruction via the sub-application to which the currently displayed sub-application page belongs; when a close instruction is detected and a native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, return the native plugin sub-application corresponding to the native plugin sub-application identifier; when a close instruction is detected and no native plugin sub-application identifier exists before the first third-party sub-application identifier in the jump path, return to the parent application.

[0207] In one embodiment, returning the native plugin sub-application corresponding to the native plugin sub-application identifier includes: when there are more than one native plugin sub-application identifiers existing before the first third-party sub-application identifier in the jump path, obtaining the native plugin sub-application identifier that is adjacent to and precedes the first third-party sub-application identifier; determining the native plugin sub-application page displayed when the obtained native plugin sub-application identifier is jumped; and displaying the determined native plugin sub-application page.

[0208] In one embodiment, passing page data corresponding to a sub-application identifier to a sub-application that corresponds to the sub-application identifier and is run by the parent application includes: switching to the parent application page used to trigger the sub-application jump; triggering the acquisition of page data corresponding to the sub-application identifier through the parent application page; and passing the page data to the sub-application that corresponds to the sub-application identifier and is run by the parent application.

[0209] In one embodiment, the computer-readable instructions cause the processor to execute the following steps after obtaining the sub-application identifier corresponding to the sub-application to which it is to jump: obtaining the parent application page identifier corresponding to the parent application page to which it is switched, and a jump path for recording the sub-application jump relationship; when the obtained sub-application identifier exists in the jump path, deleting the parent application page identifier in the jump path that is adjacent to and follows the obtained sub-application identifier; adding the obtained parent application page identifier to the end of the jump path; and moving the obtained sub-application identifier in the jump path after the added parent application page identifier.

[0210] In the aforementioned computer equipment, a parent application runs on the operating system, and child applications are run by the parent application, displaying the child application's page. When a child application jump is needed, the parent application only needs to obtain the corresponding child application identifier from the child application to which it wants to jump. It then passes the page data corresponding to that identifier to the child application running by the parent application. The child application then generates a new page based on the page data, overlaying the already displayed child application page, automatically achieving the child application jump. This avoids the time-consuming process of exiting the currently used application and restarting the intended application, improving application efficiency.

[0211] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), etc.

[0212] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0213] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this patent application should be determined by the appended claims.

Claims

DEPCT631. The task-specific program processing method applied to a terminal consists of: displaying the first child task page of the first child task, where the first child task is executed by the parent task; using the first child task to seek the second child task identifier corresponding to the second child task to which it is jumped; using the parent task to execute the second child task when jumping from the first child task to the second child task; transferring the data of the page corresponding to the second child task identifier to the second child task; and generating the second child task page above the first child task page based on the page data and displaying the second child task page.2.The method under claim 1, after the first child program seeks out the second child program identifier corresponding to the second child program to be jumped to, also includes: seeking out the jump path used to record the child program jump relationship; moving the second child program identifier to the end of the jump path when the second child program identifier exists in the jump path; and adding the second child program identifier to the end of the jump path when the second child program identifier does not exist in the jump path. 3.The methods under claim2, which also include: seeking the return command using the second child job program; determining the second child job program identifier in response to the return command; traversing the jump path to find the third child job program identifier adjacent to the second child job program identifier and positioned before the second child job program identifier; and returning to the third child job program page corresponding to the third child job program identifier4.The method under claim 3, whereby the rollback to the third child job page corresponding to the third child job identifier, includes: rolling back to the third child job page corresponding to the third child job during a jump when the third child job corresponding to the third child job identifier is being executed by the parent job in the background; and rolling back to the implicit child job page corresponding to the third child job identifier when the third child job corresponding to the third child job identifier has finished executing.5.The method under claim 2, where the second child application program is natively plugged in with the second child application program; and the move of the second child application program identifier to the end of the jump path when the second child application program identifier is present in the jump path; and the decision to assign a natively plugged in child application program identifier that is contiguous to the second child application program identifier in the jump path and is positioned after the second child application program identifier when the second child application program identifier is present in the jump path; and the move of the second child application program identifier to the end of the jump path and the removal of the contiguous natively plugged in child application program identifier in the jump path 6.The method under claim 2, where the second child application is either a native plug-in child application or a third-party child application, also includes: observing a closing statement using the second child application; returning to the first native plug-in child application corresponding to the first native plug-in child application identifier when a closing statement is detected and the first native plug-in child application identifier exists before the first third-party child application identifier in the jump path; and returning to the parent application when a closing statement is detected and the first native plug-in child application identifier does not exist before the first third-party child application identifier in the jump path. 7.The method under claim 6, whereby returning to the native plug-in child application program first, which corresponds to the native plug-in child application program first identifier, shall include: seeking the native plug-in child application program second, whereby the native plug-in child application program second is adjacent to the native third-party child application program first and is positioned before the native third-party child application program first when more than one native plug-in child application program first exists before the foremost native third-party child application program in the jump path; determining the page assignment of the native plug-in child application program second, whereby the native plug-in child application program second is the page corresponding to the native plug-in child application program second, which corresponds to the native plug-in child application program second during the jump; and displaying the page assignment of the native plug-in child application program second. 8.The method under claim1, whereby the transfer of data of the page corresponding to the second child application identifier to the second child application, shall consist of: switching to the parent application page used to trigger the child application jump, where the parent application page is the page represented by the parent application; using the parent application page to trigger the search for data of the page corresponding to the second child application identifier; and the transfer of data of the page to the second child application.9.The method under claim 1, after the first child application seeks out the second child application identifier corresponding to the second child application to be jumped to, also includes: seeking out the first parent application identifier corresponding to the first parent application identifier to which it is swapped, and the jump path used to record the child application jump relationship; deleting the second parent application identifier adjacent to the second child application identifier in the jump path and positioning it after the second child application identifier when the acquired second child application identifier is present in the jump path; adding the first parent application identifier to the end of the jump path; and moving the second child application identifier to after the first parent application identifier.10.A task processing unit, consisting of a processor and memory, where the memory stores computer-readable instructions. These instructions instruct the processor to: display the first child task page of the first child task, to which the parent task is executed; use the first child task to retrieve the second child task identifier corresponding to the second child task to which it is jumped; use the parent task to execute the second child task upon jumping from the first child task to the second child task; transfer the data of the page corresponding to the second child task identifier to the second child task; and generate the second child task page over the first child task page based on the page data and display the second child task page.11.The set of instructions under claim 10, readable by the computer, allows the processor to: seek the jump path used to record the jump relationship of the second child program; move the second child program identifier to the end of the jump path when the second child program identifier is present in the jump path; and add the second child program identifier to the end of the jump path when the second child program identifier is not present in the jump path.

12. The set of instructions under claim 11, readable by the computer, allows the processor to: seek the return instruction using the second child program; determine the second child program identifier in response to the return instruction; trace the jump path to find the third child program identifier adjacent to the second child program identifier and positioned before the second child program identifier; and return to the third child program identifier corresponding to the third child program identifier.13.The set of instructions under claim 12, by computer-readable instructions, allows the processor to: return to the third child task page corresponding to the third child task during a jump when the third child task corresponding to the third child task identifier is executed by the parent task in the background; return to the implicit child task page corresponding to the third child task identifier when the third child task corresponding to the third child task identifier has finished executing.14.The set of tools under claim11, where the child application program consists of a native plug-in child application program and computer-readable instructions, enables the processor to: determine the native plug-in child application identifier which is sequentially adjacent to the second child application identifier in the jump path and is positioned after the second child application identifier when the second child application identifier is present in the jump path; and move the second child application identifier to the end of the jump path and delete the native plug-in child application identifier sequentially adjacent to the jump path15.The set of documents under claim 11, where the child application is either a native plug-in child application or a third-party child application and the computer readable instruction allows the processor to: observe a close instruction using a second child application; return to the first native plug-in child application corresponding to the first native plug-in child application identifier when a close instruction is detected and the first native plug-in child application identifier exists before the first third-party child application identifier in the jump path; and return to the parent application when a close instruction is detected and the first native plug-in child application identifier does not exist before the first third-party child application identifier in the jump path.16.The set of instructions under claim 15, by computer-readable command, opens the path for the processor to: seek the second native plug-in child identifier when more than one first native plug-in child identifier exists before the first third-party child identifier in the jump path, where the second native plug-in child identifier is adjacent to the first third-party child identifier and is positioned before the first third-party child identifier; determine the second native plug-in child identifier page, where the second native plug-in child identifier page is the page corresponding to the second native plug-in child identifier corresponding to the second native plug-in child identifier during the jump; and display the second native plug-in child identifier page.17.The set of instructions under claim10, by computer-readable command, will allow the processor to: switch to the master application page used to trigger the jump to the child application, where the master application page is the page represented by the master application; use the master application page to trigger the search for the page corresponding to the second child application identifier; and transfer the page data to the second child application.18.The set of instructions under claim10, readable by the computer, allows the processor to: seek the first parent page identifier corresponding to the swapped first parent page identifier and the jump path used to record the child page identifier jump relationship; delete the second parent page identifier adjacent to the second child page identifier in the jump path and place it after the second child page identifier when the acquired second child page identifier is present in the jump path; add the first parent page identifier to the end of the jump path; and move the second child page identifier to after the first parent page identifier.19.A computer-readable storage medium stores computer-readable instructions. When executed by a processor, these computer-readable instructions cause the processor to execute one of the procedures outlined in claims 1 through 9.