CN115291912A

CN115291912A - Method and device for processing application program crash, medium and electronic equipment

Info

Publication number: CN115291912A
Application number: CN202210964083.0A
Authority: CN
Inventors: 李成会
Original assignee: Guangzhou Boguan Information Technology Co Ltd
Current assignee: Guangzhou Boguan Information Technology Co Ltd
Priority date: 2022-08-11
Filing date: 2022-08-11
Publication date: 2022-11-04

Abstract

The disclosure belongs to the technical field of computers, and relates to a method and device for processing application program crash, a medium and electronic equipment. The method comprises the following steps: when the application program is monitored to be crashed, acquiring a target component and verification information corresponding to the application program, wherein the verification information uniquely represents the corresponding target component; and checking the application program by using the target component and the checking information in sequence to obtain a target checking result, and reporting according to the target checking result. According to the method and the device, the target component and the verification information are used for sequentially verifying the application program, double recognition logics of collapse of the application program are added, the collapse reason is accurately reported to developers in time, an automatic and intelligent reporting mode is provided, a basis is provided for manual verification, the investment of labor cost and time cost is reduced, the collapse problem of the application program can be actively recognized from a program development end, the problem that user software is unavailable can be actively solved by the developers, and the user experience is optimized.

Description

Method and device for processing application program crash, medium and electronic equipment

Technical Field

The present disclosure relates to the field of computer technologies, and in particular, to a method and an apparatus for processing application crash, a computer-readable storage medium, and an electronic device.

Background

With the popularization and speed improvement of networks, updating and upgrading become the mainstream of software upgrading more and more, and the mode of upgrading installation packages is gradually replaced. Update upgrades bring a convenient user experience but also an increased risk of crashes. For example, the failure of component coverage for some reasons can cause the mixing of new and old versions of components, which is very easy to cause software crash. The crash can cause the software function to be completely unavailable, so that the public praise of the software slides down, and the user is lost.

For a crash caused by update failure, a general processing scheme does not perform special processing, i.e., the general crash is considered. This method can only report the crash result, but cannot report the cause of the crash. If the user needs to continue using, the program must be reinstalled or the user must turn to customer service, resulting in a poor user experience.

Accordingly, there is a need in the art to develop a new method and apparatus for handling application crashes.

It is noted that the information disclosed in the above background section is only for enhancement of understanding of the background of the present disclosure and therefore may include information that does not constitute prior art that is already known to a person of ordinary skill in the art.

Disclosure of Invention

The present disclosure is directed to a method for handling an application crash, an apparatus for handling an application crash, a computer-readable storage medium, and an electronic device, so as to overcome, at least to some extent, a technical problem that a crash situation of an application cannot be handled due to limitations of related art.

Additional features and advantages of the disclosure will be set forth in the detailed description which follows, or in part will be obvious from the description, or may be learned by practice of the disclosure.

According to a first aspect of embodiments of the present invention, there is provided a method for handling an application crash, the method comprising:

when monitoring that an application program crashes, acquiring a target component and check information corresponding to the application program, wherein the check information uniquely represents the corresponding target component;

and sequentially verifying the application program by using the target component and the verification information to obtain a target verification result, and reporting according to the target verification result.

In an exemplary embodiment of the present invention, the acquiring the target component and the verification information corresponding to the application program includes:

and acquiring a target component corresponding to the application program, and calculating the target component by using a password hash function to obtain verification information.

In an exemplary embodiment of the present invention, the sequentially verifying the application program by using the target component and the verification information to obtain a target verification result includes:

utilizing the target component to carry out existence verification on the application program to obtain a component verification result;

and based on the component checking result, carrying out integrity checking on the application program by using the checking information to obtain a target checking result.

In an exemplary embodiment of the present invention, the performing the presence check on the application program by using the target component to obtain a component check result includes:

and acquiring the component to be verified included in the application program, and performing existence verification on the component to be verified by using the target component to obtain a component verification result.

In an exemplary embodiment of the present invention, after the performing the presence check on the application program by using the target component to obtain a component check result, the method further includes:

and reporting the reason that the crash of the application program occurs to be that the target component is deleted when the component to be verified does not comprise the target component as a result of the component verification.

In an exemplary embodiment of the present invention, the performing integrity check on the application program by using the check information based on the component check result to obtain a target check result includes:

when the component to be verified comprises the target component, calculating the component to be verified to obtain component information;

and comparing the component information with the verification information to obtain a comparison result, and determining a target verification result according to the comparison result.

In an exemplary embodiment of the invention, the determining a target verification result according to the comparison result includes:

when the comparison result is that the component information and the verification information are different, determining that the target verification result is verification failure;

and when the comparison result is that the component information is the same as the verification information, determining that the target verification result is successful.

In an exemplary embodiment of the invention, after the determining that the target verification result is a verification failure, the method further includes:

and acquiring a target version of the application program, and updating the application program by using the target version.

In an exemplary embodiment of the present invention, the reporting according to the target verification result includes:

when the target verification result is verification failure, reporting that the reason of the crash of the application program is that the component to be verified is tampered or the version of the application program is wrong;

and reporting that the cause of the crash of the application program is unknown when the target verification result is successful.

According to a second aspect of the embodiments of the present invention, there is provided an apparatus for handling an application crash, including:

the information acquisition module is configured to acquire a target component and check information corresponding to an application program when the application program is monitored to be crashed, wherein the check information uniquely represents the corresponding target component;

and the program checking module is configured to check the application program in sequence by using the target component and the checking information to obtain a target checking result, and report the target checking result.

According to a third aspect of embodiments of the present invention, there is provided an electronic apparatus including: a processor and a memory; wherein the memory has stored thereon computer readable instructions which, when executed by the processor, implement a method of handling an application crash in any of the exemplary embodiments described above.

According to a fourth aspect of embodiments of the present invention, there is provided a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the method of handling an application crash in any of the above-described exemplary embodiments.

As can be seen from the foregoing technical solutions, the method for processing application crash, the apparatus for processing application crash, the computer storage medium and the electronic device in the exemplary embodiments of the present disclosure have at least the following advantages and positive effects:

in the method and the device provided by the exemplary embodiment of the disclosure, the target component and the verification information corresponding to the application program are acquired, and a data base and theoretical support are provided for verifying the application program. Furthermore, the target component and the verification information are utilized to sequentially verify the application program and report the application program according to the target verification result, double recognition logics when the application program is crashed are added, the crash reasons are accurately reported to developers in time, an automatic and intelligent reporting mode is provided, a basis is provided for manual verification, the investment of labor cost and time cost is reduced, the crash problem of the application program can be actively recognized from a program development end, the problem that user software is unavailable can be actively solved by developers, and user experience is optimized.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosure.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present disclosure and together with the description, serve to explain the principles of the disclosure. It is to be understood that the drawings in the following description are merely exemplary of the disclosure, and that other drawings may be derived from those drawings by one of ordinary skill in the art without the exercise of inventive faculty.

FIG. 1 is a flow diagram that schematically illustrates a method of handling an application crash in an exemplary embodiment of the present disclosure;

FIG. 2 schematically illustrates a flow chart of a method of verifying an application in an exemplary embodiment of the disclosure;

FIG. 3 schematically shows a flowchart of a method for further verifying an application in an exemplary embodiment of the present disclosure;

FIG. 4 schematically illustrates a flow chart of a method of determining a target verification result in an exemplary embodiment of the disclosure;

fig. 5 schematically illustrates a flowchart of a method for reporting according to a target verification result in an exemplary embodiment of the present disclosure;

FIG. 6 is a schematic structural diagram illustrating an apparatus for handling an application crash in an exemplary embodiment of the present disclosure;

FIG. 7 schematically illustrates an electronic device for implementing a method of handling an application crash in an exemplary embodiment of the disclosure;

FIG. 8 schematically illustrates a computer-readable storage medium for implementing a method of handling an application crash in an exemplary embodiment of the disclosure.

Detailed Description

Example embodiments will now be described more fully with reference to the accompanying drawings. Example embodiments may, however, be embodied in many different forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of example embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided to give a thorough understanding of embodiments of the disclosure. One skilled in the relevant art will recognize, however, that the subject matter of the present disclosure can be practiced without one or more of the specific details, or with other methods, components, devices, steps, and the like. In other instances, well-known technical solutions have not been shown or described in detail to avoid obscuring aspects of the present disclosure.

The terms "a," "an," "the," and "said" are used in this specification to denote the presence of one or more elements/components/parts/etc.; the terms "comprising" and "having" are intended to be inclusive and mean that there may be additional elements/components/etc. other than the listed elements/components/etc.; the terms "first" and "second", etc. are used merely as labels, and are not limiting on the number of their objects.

Furthermore, the drawings are merely schematic illustrations of the present disclosure and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and a repetitive description thereof will be omitted. Some of the block diagrams shown in the figures are functional entities and do not necessarily correspond to physically or logically separate entities.

With the popularization and speed improvement of networks, updating and upgrading become the mainstream of software upgrading more and more, and the mode of upgrading installation packages is gradually replaced.

The updating and upgrading refers to that a function of requesting a new version to a software developer server is added in the software, all latest components of the software are downloaded to the local, and then existing components are covered, so that the version upgrading is completed.

Update upgrades bring a convenient user experience but also an increased risk of crashes. For example, the failure of component coverage for some reasons may cause the new and old versions of components to be mixed together, which is very easy to cause software crash. And the crash can cause the software function to be completely unavailable, so that the public praise of the software is glided down, and the loss of the user is caused.

For a crash caused by update failure, the general processing scheme does not perform special processing, i.e. the general crash is treated as a general crash.

Specifically, a crash occurs during the running of the program, and the capture hook of the program captures the crash and generates a crash dump (dump) file. Meanwhile, the crash dump file and necessary information log files are uploaded to a server together for follow-up processing by developers. However, this method can only report the crash result, cannot report the cause of the crash, and cannot really help the user to solve the problem that the software is unavailable. If the user needs to continue using, the program must be reinstalled or the user must turn to customer service, resulting in a poor user experience.

In view of the problems in the related art, the present disclosure provides a method for handling application crashes. FIG. 1 is a flow chart of a method for handling an application crash, and as shown in FIG. 1, the method for handling an application crash comprises at least the following steps:

and S110, when the application program is monitored to be crashed, acquiring a target component and verification information corresponding to the application program, wherein the verification information uniquely represents the corresponding target component.

And S120, verifying the application program in sequence by using the target component and the verification information to obtain a target verification result, and reporting according to the target verification result.

In the exemplary embodiment of the disclosure, the target component and the verification information corresponding to the application program are obtained, and data base and theoretical support are provided for verifying the application program. Furthermore, the target component and the verification information are utilized to sequentially verify the application program, and the application program is reported according to the target verification result, so that double recognition logic of collapse of the application program is added, the collapse reason is accurately reported to developers in time, an automatic and intelligent reporting mode is provided, a basis is provided for manual verification, the investment of labor cost and time cost is reduced, the collapse problem of the application program can be actively recognized from a program development end, the development personnel can actively solve the problem that user software is unavailable, and the user experience is optimized.

The following describes in detail the various steps of the method for handling an application crash.

In step S110, when it is monitored that the application program crashes, a target component corresponding to the application program and verification information are obtained, where the verification information uniquely represents the corresponding target component.

In an exemplary embodiment of the present disclosure, after the application is started and run, if the application crashes, the crash capture hook may be used to capture the situation that the application crashes this time.

The crash capture hook may be an exception capture function SetUnhandledExceptionFilter, and most of the exception conditions may be captured by the exception capture function. In addition, the crash situation may also be captured in other ways, and this exemplary embodiment is not limited in this respect.

When the crash of the application program is monitored, the target component and the corresponding verification information can be further acquired.

In an alternative embodiment, a target component corresponding to the application program is obtained, and the target component is calculated by using a cryptographic hash function to obtain the verification information.

The target component may include all components in the application. And the check information may be obtained by performing separate calculation on all the components.

Specifically, a cryptographic hash function is used to calculate the target component to obtain the corresponding verification information.

Wherein the cryptographic hash function may be an MD5 Message Digest Algorithm (MD 5 Message-Digest Algorithm). The MD5 message digest algorithm is a widely used cryptographic hash function that generates a 128-bit (16-byte) hash value to ensure the integrity of the message transmission. The hash value is check information which can uniquely represent the corresponding target component.

Furthermore, the target component and the verification information can be used as a program integrity verification file to complete verification of the application program. Therefore, the program integrity check file is a mapping table of all components of the application program and corresponding check information, and the format of the program integrity check file is not limited, and may be an XML (Extensible Markup Language) file, a JSON (JSON Object Notation) file, or the like.

The program integrity file can be produced when an update package of a new version of the application program is produced, and is issued to the user machine along with the update package.

For example, the program integrity check file may be:

component1:"340E87EBB64BFD4E6DBFB09A3684E4DA",

component2:"E36C452C8F1F3FB88E21EEB405C4451F",

...

in step S120, the application program is sequentially verified by using the target component and the verification information to obtain a target verification result, and the application program is reported according to the target verification result.

In the exemplary embodiment of the present disclosure, after the target file and the verification information are acquired, the application program may be sequentially verified.

In an alternative embodiment, fig. 2 shows a flowchart of a method for verifying an application, and as shown in fig. 2, the method may at least include the following steps: in step S210, the target component is used to perform presence check on the application to obtain a component check result.

In an optional embodiment, the component to be verified included in the application program is obtained, and the target component is utilized to perform presence verification on the component to be verified to obtain a component verification result.

All components acquired under the installation catalog of the application program on the user machine can be used as components to be verified.

Further, the target component and the component to be checked are compared, whether all the target components exist in the component to be checked or not is determined, and therefore the existence check is conducted on the application program to obtain a component check result. The component verification result may be that the target component includes the component to be verified, or that the target component does not include the component to be verified.

When the component verification result is that the target component does not include the component to be verified, the reason why the application program crashes can be correspondingly reported to the server side, so that developers can further verify the component.

In an optional embodiment, when the component to be verified does not include the target component as a result of the component verification, reporting that the reason for the crash of the application program is that the component to be verified is deleted.

Since the target component is a collection of all components of the application program, when the target component is absent from the component to be verified, it indicates that the corresponding target component is deleted, thereby causing the application program to crash. Further, the reason for reporting the crash of the application program to the server side is that the target component is deleted.

In step S220, based on the component verification result, integrity verification is performed on the application program by using the verification information to obtain a target verification result.

In an alternative embodiment, fig. 3 shows a flow chart of a method for further verifying an application, and as shown in fig. 3, the method may include at least the following steps: in step S310, when the component to be verified includes the target component as a result of the component verification, the component to be verified is calculated to obtain component information.

Since the target component is a set of all components of the application, when the component to be verified includes all target components, the component to be verified may be further calculated to obtain component information.

It is worth noting that the way in which the components to be verified are computed must be the same as the way in which the target components are computed. For example, when the target component is calculated by using the cryptographic hash function, the component to be verified is also calculated by using the cryptographic hash function, so as to obtain the component information of the component to be verified in the software installation directory on the user machine.

In step S320, the component information and the verification information are compared to obtain a comparison result, and a target verification result is determined according to the comparison result.

After the component information is calculated, the component information and the verification information may be compared to obtain a comparison result. The comparison result may be that the component information and the verification information are the same, or that the component information and the verification information are different.

After determining the comparison result, a target verification result of the application program may be further determined.

In an alternative embodiment, fig. 4 shows a flowchart of a method for determining a target verification result, and as shown in fig. 4, the method may include at least the following steps: in step S410, when the comparison result is that the component information and the verification information are different, it is determined that the target verification result is a verification failure.

When the component information is different from the verification information, the program integrity verification is failed, and therefore the target verification result is verification failure.

In an alternative embodiment, a target version of the application is obtained and the application is updated with the target version.

When the verification fails, the application program update is incomplete or damaged, so that the update program can be started to update the application program so as to repair the application program.

The update procedure is another way of updating independent of the installation package. Wherein the installation package is updated offline and the update package is updated online.

Specifically, whether a new version of the application exists is queried from the server side through an HTTP (Hyper Text Transfer Protocol) Protocol. When a new version of the application program is inquired, the new version of the application program can be downloaded to the local and covered under an installation directory of a user machine.

Txt, which describes information such as the version number and update size of the software, can be read from the server to determine whether a new version of the application exists.

In step S420, when the comparison result is that the component information and the verification information are the same, it is determined that the target verification result is verification success.

When the component information is the same as the verification information, the verification of the integrity of the program is successful, and therefore, the target verification result is successful.

In the exemplary embodiment, after the application program is verified twice according to the target component and the verification information, a corresponding target verification result can be obtained, double verification logic for identifying the occurrence of the update failure of the application program is added, and a data basis and theoretical support are provided for automatically and intelligently determining the cause of the collapse of the application program.

After the target verification result is determined, the reason for the application program to crash can be reported to the server side according to the target verification result.

In an optional embodiment, fig. 5 shows a flowchart of a method for reporting according to a target verification result, and as shown in fig. 5, the method at least includes the following steps: in step S510, when the target verification result is that the verification fails, the reason why the application program crashes is reported as that the component to be verified is tampered or the version of the application program is in error.

When the target verification result is verification failure, the fact that the component to be verified is possibly tampered or multiple versions are mixed in the process of updating the application program is indicated, therefore, the reason that the application program is crashed can be reported to the server side, namely that the component to be verified is tampered or the version of the application program is wrong, and a basis and a direction are provided for manual verification.

In step S520, when the target verification result is that the verification is successful, the cause of the crash of the application program is reported to be unknown.

When the target verification result is successful, it indicates that the component to be verified is not deleted or tampered, and the situation that multiple versions are mixed in the process of updating the application program does not occur, so that the reason why the application program is crashed is reported to the server side is unknown, and developers perform manual verification to determine specific reasons.

In an exemplary embodiment of the disclosure, target components and verification information corresponding to an application are acquired, and a data base and theoretical support are provided for verifying the application. Furthermore, the target component and the verification information are utilized to sequentially verify the application program, and the application program is reported according to the target verification result, so that double recognition logic of collapse of the application program is added, the collapse reason is accurately reported to developers in time, an automatic and intelligent reporting mode is provided, a basis is provided for manual verification, the investment of labor cost and time cost is reduced, the collapse problem of the application program can be actively recognized from a program development end, the development personnel can actively solve the problem that user software is unavailable, and the user experience is optimized.

In addition, in the exemplary embodiment of the present disclosure, an apparatus for processing an application crash is also provided. Fig. 6 is a schematic diagram illustrating an apparatus for processing an application crash, and as shown in fig. 6, the apparatus 600 for processing an application crash may include: an information acquisition module 610 and a program verification module 620. Wherein:

the information acquisition module 610 is configured to acquire a target component and check information corresponding to an application program when it is monitored that the application program crashes, wherein the check information uniquely represents the corresponding target component;

and the program checking module 620 is configured to check the application program in sequence by using the target component and the checking information to obtain a target checking result, and report the target checking result.

when the component checking result indicates that the component to be checked comprises the target component, calculating the component to be checked to obtain component information;

and when the comparison result is that the component information is the same as the verification information, determining that the target verification result is verification success.

The details of the apparatus 600 for handling an application crash have been described in detail in the corresponding method for handling an application crash, and therefore are not described herein again.

It should be noted that although several modules or units of the apparatus 600 handling application crashes are mentioned in the above detailed description, such partitioning is not mandatory. Indeed, the features and functionality of two or more modules or units described above may be embodied in one module or unit, according to embodiments of the present disclosure. Conversely, the features and functions of one module or unit described above may be further divided into embodiments by a plurality of modules or units.

In addition, in an exemplary embodiment of the present disclosure, an electronic device capable of implementing the above method is also provided.

An electronic device 700 according to such an embodiment of the invention is described below with reference to fig. 7. The electronic device 700 shown in fig. 7 is only an example and should not bring any limitation to the functions and the scope of use of the embodiments of the present invention.

As shown in fig. 7, electronic device 700 is embodied in the form of a general purpose computing device. The components of the electronic device 700 may include, but are not limited to: the at least one processing unit 710, the at least one memory unit 720, a bus 730 connecting different system components (including the memory unit 720 and the processing unit 710), and a display unit 740.

Wherein the memory unit stores program code that is executable by the processing unit 710 such that the processing unit 710 performs the steps according to various exemplary embodiments of the present invention as described in the above section "exemplary method" of the present specification.

The storage unit 720 may include readable media in the form of volatile memory units, such as a random access memory unit (RAM) 721 and/or a cache memory unit 722, and may further include a read only memory unit (ROM) 723.

The memory unit 720 may also include programs/utilities 724 having a set (at least one) of program modules 725, such program modules 725 including, but not limited to: an operating system, one or more application programs, other program modules, and program data, each of which, or some combination thereof, may comprise an implementation of a network environment.

Bus 730 may be any representation of one or more of several types of bus structures, including a memory unit bus or memory unit controller, a peripheral bus, an accelerated graphics port, a processing unit, or a local bus using any of a variety of bus architectures.

The electronic device 700 may also communicate with one or more external devices 900 (e.g., keyboard, pointing device, bluetooth device, etc.), with one or more devices that enable a user to interact with the electronic device 700, and/or with any device (e.g., router, modem, etc.) that enables the electronic device 700 to communicate with one or more other computing devices. Such communication may occur through input/output (I/O) interfaces 750. Also, the electronic device 700 may communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network such as the internet) via the network adapter 760. As shown, the network adapter 760 communicates with the other modules of the electronic device 700 via the bus 730. It should be appreciated that although not shown in the figures, other hardware and/or software modules may be used in conjunction with the electronic device 700, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems, to name a few.

Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein may be implemented by software, or by software in combination with necessary hardware. Therefore, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (which may be a CD-ROM, a usb disk, a removable hard disk, etc.) or on a network, and includes several instructions to enable a computing device (which may be a personal computer, a server, a terminal device, or a network device, etc.) to execute the method according to the embodiments of the present disclosure.

In an exemplary embodiment of the present disclosure, there is also provided a computer readable storage medium having stored thereon a program product capable of implementing the above-described method of the present specification. In some possible embodiments, aspects of the invention may also be implemented in the form of a program product comprising program code means for causing a terminal device to carry out the steps according to various exemplary embodiments of the invention described in the above-mentioned "exemplary methods" section of the present description, when said program product is run on the terminal device.

Referring to fig. 8, a program product 800 for implementing the above method according to an embodiment of the present invention is described, which may employ a portable compact disc read only memory (CD-ROM) and include program code, and may be run on a terminal device, such as a personal computer. However, the program product of the present invention is not limited in this regard and, in the present document, a readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.

The program product may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. The readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium include: an electrical connection having one or more wires, a portable disk, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

A computer readable signal medium may include a propagated data signal with readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A readable signal medium may be any readable medium that is not a readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

Program code embodied on a readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device and partly on a remote computing device, or entirely on the remote computing device or server. In the case of a remote computing device, the remote computing device may be connected to the user computing device through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computing device (e.g., through the internet using an internet service provider).

Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the disclosure disclosed herein. This application is intended to cover any variations, uses, or adaptations of the disclosure following, in general, the principles of the disclosure and including such departures from the present disclosure as come within known or customary practice within the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.

Claims

1. A method of handling an application crash, the method comprising:

2. The method of handling an application crash as recited in claim 1, wherein said obtaining target components and verification information corresponding to the application comprises:

3. The method of claim 1, wherein said checking the application program using the target component and the check information in sequence to obtain a target check result comprises:

4. The method of handling an application crash as recited in claim 3, wherein said performing a presence check on the application with the target component results in a component check result comprising:

5. The method of handling an application crash as recited in claim 4, wherein after said presence checking the application with the target component yields a component check result, the method further comprises:

6. The method for handling an application crash as recited in claim 4, wherein the integrity checking the application based on the component checking result using the checking information to obtain a target checking result comprises:

7. The method of handling an application crash of claim 6, wherein said determining a target verification result based on said comparison comprises:

8. The method of handling an application crash of claim 7, wherein after said determining that said target verification result is a verification failure, said method further comprises:

9. The method of claim 7, wherein reporting according to the target check result comprises:

10. An apparatus for handling an application crash, comprising:

11. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the method of handling an application crash of any one of claims 1 to 9.

12. An electronic device, comprising:

a processor;

a memory for storing executable instructions of the processor;

wherein the processor is configured to perform the method of handling an application crash of any of claims 1-9 via execution of the executable instructions.