WO2023124929A1

WO2023124929A1 - Application managment method and apparatus, storage medium and electronic device

Info

Publication number: WO2023124929A1
Application number: PCT/CN2022/138301
Authority: WO
Inventors: 陈峥; 钟炳鑫; 金炼城
Original assignee: 北京有竹居网络技术有限公司
Priority date: 2021-12-27
Filing date: 2022-12-12
Publication date: 2023-07-06
Also published as: CN116360877A

Abstract

The present disclosure relates to an application management method and apparatus, a storage medium and an electronic device, which relate to the technical field of computers. The method comprises: loading a hook function in a preset interface, the preset interface being used for exiting the process of the application when being called by the application; and when the hook function detects that a parasite application calls the preset interface to exit the process, switching the host application corresponding to the parasite application to run in the foreground, so as to return to the display interface of the host application.

Description

Application program management method, device, storage medium and electronic device

This disclosure claims the priority of the Chinese patent application titled "202111619513.7" filed on December 27, 2021, and the application number is "application program management method, device, storage medium and electronic equipment". The contents are incorporated by reference in this disclosure.

technical field

The present disclosure relates to the technical field of computers, and in particular, to an application program management method, device, storage medium and electronic equipment.

Background technique

In related technologies, in order to make it more convenient for users to use application programs, parasitic applications such as applets and installation-free applications that do not need to be downloaded and installed in the system by users should be implemented. Since the parasitic application runs in the operating environment provided by the host application, the running status of the parasitic application is highly dependent on the operating environment provided by the host application. Therefore, in order to improve the operating performance of the parasitic application and the user experience of using the parasitic application, the host application needs to be improved. .

Contents of the invention

This Summary is provided to introduce a simplified form of concepts that are described in detail later in the Detailed Description. This summary of the invention is not intended to identify key features or essential features of the claimed technical solution, nor is it intended to be used to limit the scope of the claimed technical solution.

In a first aspect, the present disclosure provides an application program management method, including:

Loading a hook function in a preset interface, wherein the preset interface is an interface for exiting the process of the application program when called by the application program;

When the hook function captures that the parasitic application calls the preset interface to exit its own process, switch the host application corresponding to the parasitic application to the foreground to return to the display interface of the host application.

In a second aspect, the present disclosure provides an application program management device, including:

A loading module configured to load a hook function in a preset interface, wherein the preset interface is an interface for exiting the process of the application program when called by the application program;

The reporting module is configured to switch the host application corresponding to the parasitic application to the foreground to return to the display of the host application when the hook function captures that the parasitic application calls the preset interface to exit its own process interface.

In a third aspect, the present disclosure provides a computer-readable medium on which a computer program is stored, and when the program is executed by a processing device, the steps of the method described in the first aspect are implemented.

In a fourth aspect, the present disclosure provides an electronic device, including:

a storage device on which a computer program is stored;

A processing device configured to execute the computer program in the storage device to implement the steps of the method in the first aspect.

Based on the above technical solution, by loading the hook function in the preset interface, it is possible to monitor whether the parasitic application calls the preset interface to complete process suicide, so that when the parasitic application calls the preset interface to exit its own process, the host application Switch to the foreground to realize the effect of returning to the display interface of the host application after the parasitic application commits suicide, thereby improving the utilization rate of the host application. For example, when the host application is a game box, after the game process kills itself, it returns to the main interface of the game box, thereby improving the retention rate of the game box.

Other features and advantages of the present disclosure will be described in detail in the detailed description that follows.

Description of drawings

The above and other features, advantages and aspects of the various embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic and that elements and elements are not necessarily drawn to scale. In the attached picture:

Fig. 1 is a schematic flowchart of an application program management method provided according to an exemplary embodiment;

Fig. 2 is a schematic flowchart of an application management method provided according to another exemplary embodiment;

Fig. 3 is a schematic flowchart of an application management method provided according to yet another exemplary embodiment;

Fig. 4 is a schematic diagram of module connections of an application program management device according to an exemplary embodiment;

Fig. 5 is a schematic structural diagram of an electronic device according to an exemplary embodiment.

Detailed ways

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the drawings, it should be understood that the disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein; A more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for exemplary purposes only, and are not intended to limit the protection scope of the present disclosure.

It should be understood that the various steps described in the method implementations of the present disclosure may be executed in different orders, and/or executed in parallel. Additionally, method embodiments may include additional steps and/or omit performing illustrated steps. The scope of the present disclosure is not limited in this respect.

As used herein, the term "comprise" and its variations are open-ended, ie "including but not limited to". The term "based on" is "based at least in part on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one further embodiment"; the term "some embodiments" means "at least some embodiments." Relevant definitions of other terms will be given in the description below.

It should be noted that concepts such as "first" and "second" mentioned in this disclosure are only used to distinguish different devices, modules or units, and are not used to limit the sequence of functions performed by these devices, modules or units or interdependence.

It should be noted that the modifications of "one" and "multiple" mentioned in the present disclosure are illustrative and not restrictive, and those skilled in the art should understand that unless the context clearly indicates otherwise, it should be understood as "one or more" multiple".

The names of messages or information exchanged between multiple devices in the embodiments of the present disclosure are used for illustrative purposes only, and are not used to limit the scope of these messages or information.

For the convenience of understanding, terms involved in the embodiments of the present disclosure are introduced below.

Host application: The host application can be referred to as the host for short, and can be used to represent the application body that provides the operating environment for the integrated module. For example, take the host application running on the client as a social application as an example. When the module is selected, the social application may have the ability to open and display the applet. For another example, taking the host application running on the client as an installation-free platform as an example, the installation-free platform is integrated with a free-installation framework (engine), and the installation-free platform can run other native applications.

Parasitic application: A parasitic application refers to an application program that is subordinate to the host application and runs depending on the operating environment provided by the host application.

Hook function: The hook function is a program segment for processing messages, and the hook function is hung into the system through system calls. Whenever a specific message is sent, before reaching the destination window, the hook function first captures the message, that is, the hook function first obtains the control right. At this time, the hook function can process (change) the message, or continue to deliver the message without processing it, or forcibly end the message delivery.

Fig. 1 is a schematic flowchart of a method for managing application programs according to an exemplary embodiment. The application program management method disclosed in this embodiment can be executed by an electronic device, specifically by an application program management device, which can be implemented in the form of software and/or hardware and configured in the electronic device. Referring to FIG. 1 , the application program management method provided by the embodiment of the present disclosure may include the following steps.

S110. Load a hook function in a preset interface, where the preset interface is an interface for exiting a process of the application program when called by the application program.

Here, the preset interface refers to an interface for exiting the process of the application program when called by the application program. For example, in the Android (Android) system layer, the default interface can be the exit (exit) method of the java.lang.System class, the nativeExit JNI method of the java.lang.Runtime class, and the killProcess method of the android.os.Process class , the sendSignal JNI method of the android.os.Process class, and so on. In the Linux system layer, the preset interface may be an exit method, an _exit method, an abort method, a send_signal method, and the like.

Wherein, loading the hook function in the preset interface refers to performing HOOK (hook) processing on the preset interface, so as to obtain a call message that the application program invokes the preset interface to exit its own process. It should be understood that loading the hook function in the preset interface may be HOOKing the preset interface through JVM/ART virtual machine HOOK technology or C/C++ HOOK technology.

S120, when the hook function captures that the parasitic application invokes the preset interface to exit its own process, switch the host application corresponding to the parasitic application to run in the foreground, so as to return to the display interface of the host application.

Here, the parasitic application runs in the environment provided by the host application, for example, the "game box" application (host application) implemented based on the installation-free framework (engine), and the "game" application (parasitic application) runs in an independent process, independent in the task stack. Wherein, the parasitic application calling a preset interface to exit its own process refers to the parasitic application committing suicide, for example, in the case of insufficient memory resources, the parasitic application calls the preset interface to exit its own process.

When the parasitic application calls the above preset interface to exit its own process, because the preset interface has been HOOKed in advance, the hook function will capture the call information of the parasitic application calling the preset interface, so as to perceive the suicide event of the parasitic application . At this time, the electronic device switches the host application corresponding to the parasitic application to the foreground to run, so as to return to the display interface of the host application. For example, after the "game" running in the "game box" commits suicide, return to the main interface of the "game box".

In some implementation manners, the android framework startActivity can be called to switch the host application to run in the foreground through the Java layer or the Java/ART reflection mechanism.

In some implementation manners, the host application can be switched to the foreground with the startActivity function through the am command.

In some implementation manners, the android framwork can be called to switch the task stack to the task stack of the host application through the Java layer or the Java reflection mechanism, so as to switch the host application to the foreground to run.

It should be understood that, after returning to the display interface of the host application, the icon of the parasitic application is presented in a preset display manner on the display interface of the host application. Wherein, the preset display mode may be at least one of magnification, color marking, flashing display and the like.

Thus, by loading the hook function in the preset interface, it can be monitored whether the parasitic application calls the preset interface to complete process suicide, so that when the parasitic application calls the preset interface to exit its own process, the host application is switched to Run in the foreground to achieve the effect of returning to the display interface of the host application after the parasitic application commits suicide, thereby improving the utilization rate of the host application. For example, when the host application is a game box, after the game process kills itself, it returns to the main interface of the game box, thereby improving the retention rate of the game box.

Fig. 2 is a schematic flowchart of a method for managing application programs according to another exemplary embodiment. The application program management method disclosed in this embodiment can be executed by an electronic device, specifically by an application program management device, which can be implemented in the form of software and/or hardware and configured in the electronic device. Referring to FIG. 2 , the application program management provided by the embodiment of the present disclosure may include the following steps.

S210. Load a hook function in a preset interface, where the preset interface is an interface for exiting a process of the application program when called by the application program.

Here, for the specific implementation manner of step S210, reference may be made to step S110, which will not be described in detail here.

S220. When the hook function captures that the parasitic application invokes the preset interface to exit its own process, do not report the exit behavior of the parasitic application to the server as a program crash event.

Here, the parasitic application runs in the environment provided by the host application, for example, the "game box" application (host application) implemented based on the installation-free framework (engine), and the "game" application (parasitic application) runs in an independent process, independent in the task stack. For the process suicide behavior of the parasitic application, when the process suicide of the parasitic application, the buried point information that is not visible on the application interface will not be reported, so that when the actual application crash is counted, the process suicide behavior of the parasitic application is judged as a process crash Behavior.

When the parasitic application calls the above preset interface to exit its own process, the hook function will pre-capture the call information of the parasitic application calling the preset interface due to the HOOK processing of the preset interface, so as to perceive the suicide event of the parasitic application . At this time, the electronic device does not report the exit behavior of the parasitic application as a program crash event to the server, thereby excluding the process suicide behavior of the parasitic application from the statistical data of the program crash event, so as to ensure that real parasitic application process crash data can be obtained.

Fig. 3 is a schematic flowchart of a method for managing application programs according to yet another exemplary embodiment. The application program management method disclosed in this embodiment can be executed by an electronic device, specifically by an application program management device, which can be implemented in the form of software and/or hardware and configured in the electronic device. Referring to FIG. 3 , the application program management provided by the embodiment of the present disclosure may include the following steps.

S310. In the case that the parasitic application crashes, acquire state information of each function of the parasitic application when the parasitic application crashes through the pre-injected monitoring code.

Here, when the parasitic application creates a process, monitoring code may be injected into the process of the parasitic application through the host application, and the monitoring code is used to monitor the running state of each function of the parasitic application.

It should be understood that different monitoring codes can be used for different functions. For example, if a parasitic application experiences an exception when executing a try statement and causes the process to crash, the injected try catch statement can be used to capture the exception information of the try statement.

S320. Determine a crash cause of the parasitic application according to state information of each function when it crashes.

Here, the monitoring code can monitor the running state information of each function of the parasitic application. When the process of the parasitic application crashes, the monitoring code obtains the state information of each function and outputs it to the host application. The host application receives the status information of the parasitic application when it crashes, and determines the cause of the crash of the parasitic application according to the status information. Wherein, the determination of the cause of the crash may be determined according to the abnormal information in the state information of each function. For example, one type of exception information corresponds to one type of crash cause.

In some implementations, the state information of each function of the parasitic application when it crashes can be used as an input of the trained classification model to obtain the crash cause of the parasitic application.

Among them, the classification model is obtained by using the historical crash data marked with the crash cause of the parasitic application to train the machine learning model.

Here, for the parasitic application, the historical crash data of the parasitic application can be collected, and the collected historical crash data can be marked with the cause of the crash to obtain a training sample, and then the training sample can be used to train the machine learning model to obtain the classification model. Wherein, the historical crash data may be the status information of each function when the parasitic application crashes and is collected during the historical operation of the parasitic application.

It is worth noting that the machine learning model can be a neural network model, such as a convolutional neural network (Convolutional Neural Networks, CNN).

Therefore, through the trained classification model, the cause of the crash of the parasitic application can be quickly located, and the cause of the crash can be located locally in the host application, without uploading the crash description information of the parasitic application to the server for manual analysis.

S330. Display the cause of the crash and/or a solution corresponding to the cause of the crash on the display interface of the host application.

Here, when the parasitic application crashes, return to the display interface of the host application, and display the crash cause of the parasitic application crash and/or the solution corresponding to the crash cause on the display interface of the host application.

Wherein, at least one solution can be matched for each crash cause. By showing the cause of the crash and/or the solution to the user, the user can understand the cause of the crash of the parasitic application and obtain a corresponding solution to the crash at the first time. Exemplarily, the crash cause and/or solution may be displayed in a pop-up window on the display interface of the host application. For example, when the host application is the "Game Box", if the process of the "mini game" running on the "Game Box" crashes, it can return to the display interface of the "Game Box" and display on the display interface of the "Game Box" Crash causes and/or solutions for Mini Games.

In some embodiments, when the solution is a solution that can be executed automatically by the host application, the solution is executed by the host application to solve the problem of the crash of the parasitic application. For example, when the solution is to identify the need to modify the system parameter configuration, the system parameter configuration can be automatically modified under the condition of obtaining user authorization, so that the host application has an operating environment for normally running the parasitic application.

Therefore, by injecting the monitoring code into the parasitic application, the monitoring code is used to obtain the status information of each function of the parasitic application when it crashes, and according to the status information, the cause of the crash of the parasitic application is determined, and then the display interface of the host application is displayed. The cause of the crash and/or the corresponding solution, so that the cause of the crash can be fed back to the user in time and a solution can be provided, which can greatly improve the user experience of the user using the host application.

In some implementations, when the parasitic application crashes, the interface of the parasitic application and the text information entered by the user in the interface are saved, and when the parasitic application is restarted, the saved interface is presented, and the saved text information is loaded on the interface in the corresponding position.

Here, when the parasitic application crashes, the interface of the parasitic application when it crashes and the text information entered by the user in the interface can be saved by the host application. For example, when the user is inputting text information in the parasitic application, the parasitic application crashes. At this time, the host application saves the interface of the parasitic application when it crashes and saves the text information entered by the user.

When the user restarts the parasitic application, the host application will transfer the saved interface and text information to the parasitic application. According to the saved interface and text information, the parasitic application will directly enter the saved interface after the parasitic application is restarted, and open the Load the saved text information in .

Thus, even if the parasitic application crashes, the text information entered by the user in real time can be recorded. After restarting the parasitic application, the user does not need to re-enter the text information again, which can greatly improve the user experience of using the application program.

In some implementations, the memory objects of the host application and the parasitic application can be serialized, so as to obtain the interface of the parasitic application when it crashes and the text information input by the user.

In some implementations, during the running of the parasitic application, the host application can record the screen of the interface of the parasitic application to obtain the screen recording file; The interface and the text information entered by the user in the interface are saved.

Wherein, determining the crashed interface of the parasitic application in the screen recording file may be to perform image recognition on the image in the screen recording file, so as to locate the crashing interface of the parasitic application according to the recognized interface identifier or key image elements. Of course, text recognition can also be performed on the image frame when the parasitic application crashes in the screen recording file, to obtain the text information input by the user in the interface.

It is worth noting that the host application can save the interface of the parasitic application and the text information entered by the user in the interface only after obtaining the user's authorization. If the user's authorization is not obtained, the host application disables the function of saving the interface of the parasitic application and the text information input by the user in the interface. Moreover, the interface and text information saved by the host application are only used to restore the crashed interface. For example, the saved interface and text information are stored in a file sandbox, which is only accessible by the parasitic application when restoring the interface, and after the restoration of the interface of the parasitic application is completed, the information in the file sandbox is updated. delete.

Fig. 4 is a schematic diagram of module connections of an application program management device according to an exemplary embodiment. As shown in FIG. 4 , an embodiment of the present disclosure provides an application management device, and the device 400 may include:

The loading module 401 is configured to load a hook function in a preset interface, wherein the preset interface is an interface for exiting the process of the application program when called by the application program;

The switching module 402 is configured to switch the host application corresponding to the parasitic application to the foreground to return to the UI.

In some embodiments, the device 400 also includes:

The reporting module is configured to not report the exit behavior of the parasitic application to the server as a program crash event when the hook function captures that the parasitic application invokes the preset interface to exit its own process.

In some embodiments, the device 400 also includes:

The display module is configured to present the icon of the parasitic application in the display interface of the host application in a preset display manner after returning to the display interface of the host application.

In some embodiments, the device 400 also includes:

The acquiring module is configured to acquire the state information of each function of the parasitic application when the parasitic application crashes through the pre-injected monitoring code when the parasitic application crashes;

The determining module is configured to determine the cause of the crash of the parasitic application according to the state information of each function when it crashes;

The display module is configured to display the cause of the crash and/or a solution corresponding to the cause of the crash on the display interface of the host application.

In some embodiments, the determination module is specifically configured to:

Using the state information of each function when it crashes as the input of the trained classification model to obtain the crash cause of the parasitic application;

Wherein, the classification model is obtained by using historical crash data marked with crash causes of the parasitic application to train a machine learning model.

In some embodiments, the device 400 also includes:

A saving module configured to save the interface of the parasitic application and the text information input by the user in the interface when the parasitic application crashes;

The recovery module is configured to present the saved interface when restarting the parasitic application, and load the saved text information into a corresponding position of the interface.

In some embodiments, the preservation module includes:

The recording unit is configured to record a screen of the interface of the parasitic application through the host application during the operation of the parasitic application to obtain a screen recording file;

The recording unit is configured to save the crashed interface of the parasitic application in the screen recording file and the text information input by the user in the interface when the parasitic application crashes.

The specific implementation of each functional module of the device in the above embodiment has been described in detail in the part about the method, and will not be repeated here.

Referring now to FIG. 5 , it shows a schematic structural diagram of an electronic device 600 suitable for implementing the embodiments of the present disclosure. The terminal equipment in the embodiment of the present disclosure may include but not limited to such as mobile phone, notebook computer, digital broadcast receiver, PDA (personal digital assistant), PAD (tablet computer), PMP (portable multimedia player), vehicle terminal (such as mobile terminals such as car navigation terminals) and fixed terminals such as digital TVs, desktop computers and the like. The electronic device shown in FIG. 5 is only an example, and should not limit the functions and scope of use of the embodiments of the present disclosure.

As shown in FIG. 5, an electronic device 600 may include a processing device (such as a central processing unit, a graphics processing unit, etc.) 601, which may be randomly accessed according to a program stored in a read-only memory (ROM) 602 or loaded from a storage device 608. Various appropriate actions and processes are executed by programs in the memory (RAM) 603 . In the RAM 603, various programs and data necessary for the operation of the electronic device 600 are also stored. The processing device 601, ROM 602, and RAM 603 are connected to each other through a bus 604. An input/output (I/O) interface 605 is also connected to the bus 604 .

Typically, the following devices can be connected to the I/O interface 605: input devices 606 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; including, for example, a liquid crystal display (LCD), speaker, vibration an output device 607 such as a computer; a storage device 608 including, for example, a magnetic tape, a hard disk, etc.; and a communication device 609. The communication means 609 may allow the electronic device 600 to communicate with other devices wirelessly or by wire to exchange data. While FIG. 5 shows electronic device 600 having various means, it should be understood that implementing or having all of the means shown is not a requirement. More or fewer means may alternatively be implemented or provided.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product, which includes a computer program carried on a non-transitory computer readable medium, where the computer program includes program code for executing the method shown in the flowchart. In such an embodiment, the computer program may be downloaded and installed from a network via communication means 609, or from storage means 608, or from ROM 602. When the computer program is executed by the processing device 601, the above-mentioned functions defined in the methods of the embodiments of the present disclosure are performed.

It should be noted that the computer-readable medium mentioned above in the present disclosure may be a computer-readable signal medium or a computer-readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable Programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above. In the present disclosure, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In the present disclosure, however, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave carrying computer-readable program code therein. Such propagated data signals may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which can transmit, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device . Program code embodied on a computer readable medium may be transmitted by any appropriate medium, including but not limited to wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

In some embodiments, the electronic device can communicate with any currently known or future-developed network protocol such as HTTP (HyperText Transfer Protocol, Hypertext Transfer Protocol), and can communicate with digital data in any form or medium ( For example, communication networks) interconnect. Examples of communication networks include local area networks ("LANs"), wide area networks ("WANs"), internetworks (e.g., the Internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed network of.

The above-mentioned computer-readable medium may be included in the above-mentioned electronic device, or may exist independently without being incorporated into the electronic device.

The above-mentioned computer-readable medium carries one or more programs, and when the above-mentioned one or more programs are executed by the electronic device, the electronic device: loads a hook function in a preset interface, wherein the preset interface is in The interface used to exit the process of the application program when called by the application program; when the hook function captures that the parasitic application calls the preset interface to exit its own process, switch the host application corresponding to the parasitic application Run in the foreground to return to the display interface of the host application.

Computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, or combinations thereof, including but not limited to object-oriented programming languages—such as Java, Smalltalk, C++, and Includes conventional procedural programming languages - such as "C" or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (for example, using an Internet service provider to connected via the Internet).

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or portion of code that contains one or more logical functions for implementing specified executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified functions or operations , or may be implemented by a combination of dedicated hardware and computer instructions.

The modules involved in the embodiments described in the present disclosure may be implemented by software or by hardware. Wherein, the name of the module does not constitute a limitation on the module itself under certain circumstances.

The functions described herein above may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), System on Chips (SOCs), Complex Programmable Logical device (CPLD) and so on.

In the context of the present disclosure, a machine-readable medium may be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media would include one or more wire-based electrical connections, portable computer discs, hard drives, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory), optical fiber, compact disk read only memory (CD-ROM), optical storage, magnetic storage, or any suitable combination of the foregoing.

The above description is only a preferred embodiment of the present disclosure and an illustration of the applied technical principles. Those skilled in the art should understand that the disclosure scope involved in this disclosure is not limited to the technical solution formed by the specific combination of the above-mentioned technical features, but also covers the technical solutions formed by the above-mentioned technical features or Other technical solutions formed by any combination of equivalent features. For example, a technical solution formed by replacing the above-mentioned features with (but not limited to) technical features with similar functions disclosed in this disclosure.

In addition, while operations are depicted in a particular order, this should not be understood as requiring that the operations be performed in the particular order shown or performed in sequential order. Under certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while the above discussion contains several specific implementation details, these should not be construed as limitations on the scope of the disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are merely example forms of implementing the claims. Regarding the apparatus in the foregoing embodiments, the specific manner in which each module executes operations has been described in detail in the embodiments related to the method, and will not be described in detail here.

Claims

A method of application management comprising:

Loading a hook function in a preset interface, wherein the preset interface is an interface for exiting the process of the application program when called by the application program;

When the hook function captures that the parasitic application calls the preset interface to exit its own process, switch the host application corresponding to the parasitic application to the foreground to return to the display interface of the host application.
The application program management method according to claim 1, further comprising:

When the hook function captures that the parasitic application invokes the preset interface to exit its own process, the exit behavior of the parasitic application is not reported to the server as a program crash event.
The application program management method according to claim 1, wherein the method further comprises:

After returning to the display interface of the host application, the icon of the parasitic application is presented in a preset display manner on the display interface of the host application.
The application program management method according to any one of claims 1 to 3, wherein the method further comprises:

In the case that the parasitic application crashes, the state information of each function of the parasitic application when the parasitic application crashes is obtained through pre-injected monitoring code;

determining the cause of the crash of the parasitic application according to the state information of each function when it crashes;

The cause of the crash and/or the solution corresponding to the cause of the crash are displayed on the display interface of the host application.
The application program management method according to claim 4, wherein said determining the crash cause of the parasitic application according to the state information of each function when it crashes comprises:

Using the state information of each function when it crashes as the input of the trained classification model to obtain the crash cause of the parasitic application;

Wherein, the classification model is obtained by using historical crash data marked with crash causes of the parasitic application to train a machine learning model.
The application program management method according to claim 4, wherein said method further comprises:

When the parasitic application crashes, save the interface of the parasitic application and the text information input by the user in the interface;

When the parasitic application is restarted, the saved interface is presented, and the saved text information is loaded into a corresponding position of the interface.
The application program management method according to claim 6, wherein in the case of the parasitic application crashing, saving the interface of the parasitic application and the text information input by the user in the interface comprises:

During the running process of the parasitic application, the interface of the parasitic application is recorded through the host application to obtain a screen recording file;

In the case that the parasitic application crashes, the interface of the parasitic application at the time of crash and the text information input by the user in the interface in the screen recording file are saved.
An application management device, comprising:

A loading module configured to load a hook function in a preset interface, wherein the preset interface is an interface for exiting the process of the application program when called by the application program;

The reporting module is configured to switch the host application corresponding to the parasitic application to the foreground to return to the display of the host application when the hook function captures that the parasitic application calls the preset interface to exit its own process interface.
A computer-readable medium, on which a computer program is stored, wherein, when the program is executed by a processing device, the steps of the method according to any one of claims 1-7 are implemented.
An electronic device comprising:

a storage device on which a computer program is stored;

A processing device configured to execute the computer program in the storage device to implement the steps of the method according to any one of claims 1-7.