CN109508249B - Crash processing method and device and electronic equipment - Google Patents
Crash processing method and device and electronic equipment Download PDFInfo
- Publication number
- CN109508249B CN109508249B CN201811359839.9A CN201811359839A CN109508249B CN 109508249 B CN109508249 B CN 109508249B CN 201811359839 A CN201811359839 A CN 201811359839A CN 109508249 B CN109508249 B CN 109508249B
- Authority
- CN
- China
- Prior art keywords
- crash
- software development
- development kit
- party software
- application program
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
- G06F11/0793—Remedial or corrective actions
Abstract
The application provides a crash processing method and device and electronic equipment, and relates to the technical field of computers. The method comprises the steps of obtaining a bytecode file of an application program, wherein the bytecode file comprises a bytecode of a third-party software development kit contained in the application program; and constructing a flow, namely injecting codes for processing the crash of the third-party software development kit into the byte code file to obtain a new version installation package of the application program. The method can quickly locate and automatically repair the collapse of the third-party software development kit in the application program, has simple processing process, effectively improves the maintenance efficiency of the application program, and saves the processing time, thereby reducing the number of users affected by the collapse of the third-party software development kit, improving the quality of the application program and improving the user experience.
Description
Technical Field
The application relates to the technical field of computers, in particular to a crash processing method and device and electronic equipment.
Background
At present, in the development of Application programs (APPs), some functions already developed or new functions or new services provided by software service providers are often introduced to simplify the development process and improve the efficiency of software development.
Software developers typically implement extensions to new functions or new services of APPs by integrating third party Software Development Kits (SDKs). However, due to various reasons such as code errors, operating environment limitations, network unavailability, etc., the third-party SDK cannot execute the code correctly, resulting in unexpected APP stop and exit, i.e., a crash, for the developer. If the collapse problem can not be repaired in time, the quality of the APP is seriously influenced, and the user experience is reduced.
Disclosure of Invention
In view of the above, embodiments of the present disclosure provide a crash handling method, a crash handling apparatus, and an electronic device to solve the above problems.
In a first aspect, an embodiment of the present application provides a crash processing method, configured to process a crash problem of a third-party software development kit, where the method includes:
acquiring a bytecode file of an application program, wherein the bytecode file comprises a bytecode of a third-party software development kit contained in the application program;
and constructing a flow, namely injecting a code for processing the crash of the third-party software development kit into the byte code file to obtain the new version installation of the application program.
Optionally, injecting code for handling a third party software development kit crash into the bytecode file, including:
injecting implementation code for resolving a third party software development kit crash into the bytecode file, such that the application resolves the third party software development kit crash by executing the implementation code.
Optionally, injecting code for handling a third party software development kit crash into the bytecode file, further comprising:
and injecting capture abnormal codes for capturing the third-party software development kit crash into the bytecode file, so that the application program ignores the currently occurring third-party software development kit crash and continues to run by executing the capture abnormal codes.
Optionally, injecting code for handling a third party software development kit crash into the bytecode file, further comprising:
and injecting a method return code for interrupting the crash of the third-party software development kit into the byte code file, so that the application program interrupts the method blocks in the currently crashed third-party software development kit byte code by executing the method return code.
In a second aspect, an embodiment of the present application further provides a crash processing apparatus, where the apparatus includes:
the system comprises an acquisition module, a storage module and a processing module, wherein the acquisition module is used for acquiring a bytecode file of an application program, and the bytecode file comprises a bytecode of a third-party software development kit contained in the application program;
and the building module is used for building a flow, and injecting a code for processing the crash of the third-party software development kit into the byte code file to obtain a new version installation package of the application program.
Optionally, the building module is specifically configured to:
injecting implementation code for resolving a third party software development kit crash into the bytecode file so that the application resolves the third party software development kit crash by executing the implementation code.
Optionally, the building module is further configured to:
and injecting capture abnormal codes for capturing the third-party software development kit crash into the byte code file, so that the application program ignores the currently occurring third-party software development kit crash and continues to run by executing the capture abnormal codes.
Optionally, the building module is further configured to:
and injecting a method return code for interrupting the crash of the third-party software development kit into the byte code file, so that the application program interrupts the method blocks in the currently crashed third-party software development kit byte code by executing the method return code.
In a third aspect, an embodiment of the present application further provides an electronic device, where the electronic device includes a processor and a nonvolatile memory storing computer instructions, and when the computer instructions are executed by the processor, the crash processing method described in the foregoing embodiment is implemented.
In a fourth aspect, an embodiment of the present application further provides a storage medium, where the storage medium includes a computer program, and when the computer program runs, the electronic device where the storage medium is located is controlled to execute the crash processing method described in the foregoing embodiment.
Compared with the prior art, the method has the following beneficial effects:
according to the crash processing method and device and the electronic equipment, a new process is established, codes for processing the crash of the third-party software development kit are injected into a byte code file of the application program, a new version installation package of the application program is obtained, and after the new version installation package of the application program is installed, the codes are executed to process the crash of the third-party software development kit during operation. The scheme provided by the application can be used for quickly positioning and automatically repairing the collapse of the third-party software development kit in the application program, the processing process is simple and effective, the maintenance efficiency of the application program is improved, the processing time is saved, the number of users affected by the collapse of the third-party software development kit is reduced, the quality of the application program is improved, and the user experience is improved.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings needed to be used in the embodiments are briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present application and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained according to the drawings without inventive efforts.
Fig. 1 is a schematic structural diagram of a software development system provided in an embodiment of the present application;
fig. 2 is a schematic structural diagram of an electronic device according to an embodiment of the present application;
FIG. 3 is a flowchart illustrating a crash handling method according to an embodiment of the present disclosure;
fig. 4 is a schematic structural diagram of a crash processing apparatus according to an embodiment of the present application.
Icon: 100-a software development system; 200-an electronic device; 300-crash handling means; 110-a development end; 120-a client; 130-a server; 210-a processor; 220-non-volatile memory; 230-a communication unit; 240-I/O cell; 310-an acquisition module; 320-a building block; 111-a software development platform; 112-crash reporting platform.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are some embodiments of the present application, but not all embodiments. Thus, the following detailed description of the embodiments of the present application, presented in the accompanying drawings, is not intended to limit the scope of the claimed application, but is merely representative of selected embodiments of the application. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, it need not be further defined and explained in subsequent figures.
The third-party SDKs include open-source SDKs and closed-source SDKs. Typical open source SDKs, such as OkHttp, Retrofit, etc., have publicly published source code on gitubs, which everyone can refer to and modify. Typical closed-source SDKs such as WeChat login SDKs, microblog sharing SDKs and millet pushing SDKs are all SDKs provided by software service providers for external developers to use services or functions of the software service providers, and the external developers can only be used in an integrated manner and cannot view source codes of the SDKs.
In the prior art, for an open-source SDK, an application developer can analyze a source code of the open-source SDK and repair a crash problem by itself, or feed back the crash problem to an author or a publisher of the open-source SDK, and wait for the author or the publisher to process, solve and update an SDK version. However, for the closed-source SDK, the application developer cannot analyze the source code, so that the crash problem can only be fed back to wait for the author or the publisher to process and solve, and a certain time is required for the waiting process, and in this time, the crash of the third-party SDK that has occurred but has not been solved will affect more APP users, which is not favorable for building user goodness.
In order to overcome the problems of the prior art, the applicant has studied to provide a solution given in the following examples.
Referring to fig. 1, the present application provides a crash handling method, which is applied to the software development system 100 shown in fig. 1, where the software development system 100 includes an initiating terminal 110, a client terminal 120 and a server 130, where the initiating terminal 110 and the client terminal 120 may be an electronic device 200, and the server 130 communicates with the initiating terminal 110 and the client terminal 120, respectively. The development end 110 includes a software development platform 111 and a crash reporting platform 112, a software developer uploads an application installation package to the server 130 through the software development platform 111, and the client 120 downloads and obtains the application installation package from the server 130 and installs and runs the application installation package, wherein a certain number of third-party SDKs including an SDK reported by a crash are integrated in the application installation package.
If the third-party SDK crashes during the running process of the application program in the client 120, when the application program runs again, the crash report SDK is triggered, crash information of the third-party SDK crash is fed back to the crash report platform 112, and an application program developer can check the crash information in the crash report platform 112, analyze the crash reason, and find out a solution. The crash reporting platform 112 may be, but is not limited to, a Bunly, Umeng, Fabric, etc.
Referring to fig. 2, in the present embodiment, the development end 110 and the client 120 shown in fig. 1 may be an electronic device 200 shown in fig. 2. The electronic device 200 includes a processor 210 and a non-volatile memory 220 storing computer instructions, and optionally, the electronic device 200 further includes a communication unit 230 for information interaction with an external device and an I/O unit 240 for information input and output.
The electronic device 200 may be, but is not limited to, a smart phone, a Personal Computer (PC), a tablet PC, a Personal Digital Assistant (PDA), a Mobile Internet Device (MID), and the like. The Operating System (OS) of the electronic device 200 may be, but is not limited to, an Android system, an ios (internet operating system) system, a Windows phone system, and the like. The Processor 210 may be a general-purpose Processor including a Central Processing Unit (CPU), a Network Processor (NP), and the like; but may also be a Digital Signal Processor (DSP)), an Application Specific Integrated Circuit (ASIC), an off-the-shelf programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof, that performs or implements the methods, steps, and logic blocks disclosed in embodiments of the present invention.
The processor 210, the nonvolatile memory 220, the communication unit 230, and the I/O unit 240 are electrically connected to each other directly or indirectly to achieve data transmission or interaction. For example, the components may be electrically connected to each other via one or more communication buses or signal lines. The nonvolatile memory 220 is used for storing programs or data, and the crash processing apparatus 300 provided in the embodiment of the present application may be stored in the nonvolatile memory 220 in the form of a storage medium, and specifically, the crash processing apparatus 300 includes at least one software functional module that may be stored in the nonvolatile memory 220 in the form of software or firmware or solidified in an operating system of the electronic device 200. The processor 210 is used for executing executable modules in the nonvolatile memory 220, such as software functional modules and computer programs included in the crash processing device 300.
Referring to fig. 3, an embodiment of the present application further provides a crash handling method, and fig. 3 is a schematic flowchart of the method. The method is used for solving the problem of the crash of the third-party SDK, and may be applied to the electronic device 200 shown in fig. 2, and a specific flow of the crash processing method will be described in detail below.
The crash processing method comprises the following steps:
step S11, obtaining a bytecode file of an application program, where the bytecode file includes a bytecode of a third-party software development kit included in the application program.
Bytecode is a way that an application exists in compiling into machine-executable code, for example, Java code of Android system application (Android App) is converted into class files in the compilation process, which are Java bytecodes.
In this embodiment, as an optional implementation manner, a bytecode modification class library set in the software development platform 111 may be used to obtain and edit a bytecode file of the application program. The bytecode modification class library is a class library which can directly edit a target code without a source code, namely, the original code flow of the application program can be directly modified. The bytecode modification class library can be, but is not limited to, ASM, AspectJ, BCEL, Byte Buddy, CGLIB, Cojen, Javassist, Serp, etc.
Step S12, constructing a flow, and injecting codes for processing third-party software development kit crash into the byte code file to obtain a new version installation package of the application program.
As described above, the application developer analyzes the crash reason according to the crash information of the third-party SDK viewed in the crash report platform 112, finds out the processing scheme, writes the processing scheme as a code, and integrates the code into the software development platform 111.
When the software development platform 111 constructs the installation package of the application program, the existing process is to load the bytecode file of the APP through the bytecode modification class library, and then generate a new version installation package of the APP after processing of other steps, where the other steps may include processing pictures, character strings, audio and video resources, and the like, and are not described in detail herein. According to the method and the device, a construction process is added after the process of loading the byte code file of the APP, the byte code file or the byte code method block with the error is found in a traversing mode, and the written code for processing the third-party SDK breakdown is automatically injected into the byte code file or the byte code method block with the error. After the new version installation package of the application program is generated, the development end 110 uploads the new version installation package containing the processing code to the server 130, and the client 120 downloads and installs the new version installation package, so that the application program can not generate the same type of third-party SDK crash in the running process, and the generated third-party SDK crash is solved.
In this embodiment, there are three possible cases for the processing of the third-party SDK crash, and correspondingly, the step S12 may have the following three implementation manners.
The first embodiment: injecting implementation code for resolving a third party software development kit crash into the bytecode file, such that the application resolves the third party software development kit crash by executing the implementation code.
For the first processing situation, the application developer can analyze a specific crash reason according to the crash information of the third-party SDK checked in the crash report platform 112, and can find out a corresponding solution, and can write an implementation code for solving the crash of the third-party SDK according to the solution. The software development platform 111 may inject the implementation code into the bytecode file when constructing a new version installation package of the APP, and when the new version APP runs on the client 120, if the new version APP runs to a part where the crash occurs again, the newly injected implementation code will be executed, so that the occurrence of the third-party SDK crash can be solved.
The second embodiment: and injecting capture abnormal codes for capturing the third-party software development kit crash into the byte code file, so that the application program ignores the currently occurring third-party software development kit crash and continues to run by executing the capture abnormal codes.
For the second processing case, although the application developer can analyze the specific crash cause, but cannot find the corresponding solution, the software development platform 111 may inject a capture exception command into the bytecode file when executing a new building process, for example: try { } catch (Throwable) { }. The captured crash does not affect the continuous operation of other codes of the application program, namely, the new version APP containing the captured abnormal codes can continuously operate by ignoring the current third-party SDK crash instead of directly exiting the operation.
In a third embodiment, a method return code for interrupting the third-party software development kit crash is injected into the bytecode file, so that the application program interrupts the method blocks in the currently crashed third-party software development kit bytecode by executing the method return code.
For the third processing situation, the application developer cannot analyze a specific crash reason and even find a corresponding solution, the software development platform 111 may inject a Method return (Method return) command into the bytecode file when executing a new building process, and when a new version APP including a Method return code runs to a Method block of a third-party SDK where a crash has occurred, the software development platform may directly interrupt running, that is, no longer execute subsequent codes in the Method block, and instead execute other methods or functions of the APP.
Referring to fig. 4, fig. 4 is a schematic structural diagram of functional modules of the crash processing apparatus 300 shown in fig. 2. It is to be understood that, since the specific functions of the functional modules of the crash processing apparatus 300 have been introduced in the above method steps, only the functional modules of the crash processing apparatus 300 will be briefly described below.
The crash processing apparatus 300 includes:
the obtaining module 310 is configured to obtain a bytecode file of an application, where the bytecode file includes a bytecode of a third-party software development kit included in the application.
And the building module 320 is used for building a process, and injecting a code for processing the crash of the third-party software development kit into the byte code file to obtain a new version installation package of the application program.
To sum up, according to the crash processing method, the crash processing device, and the electronic device provided in the embodiments of the present application, a new process is established, and a code for processing a crash of a third-party software development kit is injected into a bytecode file of an application program to obtain a new version installation package of the application program, and after the new version installation package of the application program is installed, the crash of the third-party software development kit is processed by executing the code during running. The scheme provided by the application can be used for quickly positioning and automatically repairing the collapse of the third-party software development kit in the application program, the collapse information is not required to be fed back to the publisher of the third-party software development kit and is waited for the publisher to process, the processing process is simple and effective, the maintenance efficiency of the application program is improved, the processing time is saved, the number of users affected by the collapse of the third-party software development kit is reduced, the quality of the application program is improved, and the user experience is improved.
In the embodiments provided in the present application, it should be understood that the disclosed system and method may be implemented in other ways. The system and method embodiments described above are merely illustrative and, for example, the flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of apparatus, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). 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 the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
In addition, functional modules in the embodiments of the present application may be integrated together to form an independent part, or each module may exist separately, or two or more modules may be integrated to form an independent part.
It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in the process, method, article, or apparatus that comprises the element. Moreover, the terms "first," "second," and the like are used solely to distinguish one from another, and are not to be construed as indicating or implying a relative importance of the referenced item.
The above description is only a preferred embodiment of the present application and is not intended to limit the present application, and various modifications and changes may be made by those skilled in the art. Any modification, equivalent replacement, improvement and the like made within the spirit and principle of the present application shall be included in the protection scope of the present application.
Claims (8)
1. A crash handling method for handling a crash problem of a third party software development kit, the method comprising:
acquiring a bytecode file of an application program, wherein the bytecode file comprises a bytecode of a third-party software development kit contained in the application program;
constructing a flow, namely injecting a code for processing the crash of the third-party software development kit into the byte code file to obtain a new version installation package of the application program;
the injecting code for handling third party software development kit crashes into the bytecode file includes:
and injecting a method return code for interrupting the crash of the third-party software development kit into the bytecode file, so that the application program interrupts the method blocks in the bytecode of the currently crashed third-party software development kit by executing the method return code, and when the application program containing the method return code runs to the method blocks of the third-party software development kit which is crashed once, the running is directly interrupted, the subsequent codes in the method blocks of the third-party software development kit which is crashed once are not executed any more, and other methods or functions of the application program containing the method return code are executed instead.
2. A crash processing method as recited in claim 1, wherein injecting code for handling a third party software development kit crash into the bytecode file comprises:
injecting implementation code for resolving a third party software development kit crash into the bytecode file so that the application resolves the third party software development kit crash by executing the implementation code.
3. A crash processing method as recited in claim 2, wherein injecting code for handling a third party software development kit crash into the bytecode file, further comprising:
and injecting capture abnormal codes for capturing the third-party software development kit crash into the byte code file, so that the application program ignores the currently occurring third-party software development kit crash and continues to run by executing the capture abnormal codes.
4. A crash processing apparatus, the apparatus comprising:
the system comprises an acquisition module, a storage module and a processing module, wherein the acquisition module is used for acquiring a bytecode file of an application program, and the bytecode file comprises a bytecode of a third-party software development kit contained in the application program;
the building module is used for building a process, and injecting a code for processing the crash of the third-party software development kit into the byte code file to obtain a new version installation package of the application program;
the building module is further used for injecting a method return code for interrupting the third-party software development kit crash into the bytecode file, so that the application program interrupts the method blocks in the bytecode of the currently crashed third-party software development kit by executing the method return code, when the application program containing the method return code runs to the method blocks of the third-party software development kit that is crashed once, the running is directly interrupted, subsequent codes in the method blocks of the third-party software development kit that is crashed once are not executed any more, and other methods or functions of the application program containing the method return code are executed instead, wherein the method return code is a method return command.
5. A crash processing apparatus as recited in claim 4, wherein the build module is specifically configured to:
injecting implementation code for resolving a third party software development kit crash into the bytecode file, such that the application resolves the third party software development kit crash by executing the implementation code.
6. A crash processing apparatus as recited in claim 5, wherein the build module is further to:
and injecting capture abnormal codes for capturing the third-party software development kit crash into the bytecode file, so that the application program ignores the currently occurring third-party software development kit crash and continues to run by executing the capture abnormal codes.
7. An electronic device comprising a processor and a non-volatile memory having computer instructions stored thereon, wherein the computer instructions, when executed by the processor, implement the crash handling method of any one of claims 1-3.
8. A storage medium, characterized in that the storage medium comprises a computer program which, when running, controls an electronic device in which the storage medium is located to perform the crash handling method of any one of claims 1-3.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811359839.9A CN109508249B (en) | 2018-11-15 | 2018-11-15 | Crash processing method and device and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811359839.9A CN109508249B (en) | 2018-11-15 | 2018-11-15 | Crash processing method and device and electronic equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109508249A CN109508249A (en) | 2019-03-22 |
| CN109508249B true CN109508249B (en) | 2022-05-31 |
Family
ID=65748653
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811359839.9A Active CN109508249B (en) | 2018-11-15 | 2018-11-15 | Crash processing method and device and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109508249B (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110765008B (en) * | 2019-10-09 | 2023-08-18 | 网宿科技股份有限公司 | Data processing method and device |
| CN110837388B (en) * | 2020-01-09 | 2020-05-29 | 炬星科技（深圳）有限公司 | Software upgrading method of robot, upgrading server, robot and storage medium |
| CN111857779B (en) * | 2020-07-20 | 2024-04-12 | 深圳市欢太科技有限公司 | Information processing method, information processing device, electronic equipment and storage medium |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105808266A (en) * | 2016-03-29 | 2016-07-27 | 广州华多网络科技有限公司 | Code operation method and device |
| CN108089870A (en) * | 2016-11-21 | 2018-05-29 | 百度在线网络技术（北京）有限公司 | For repairing the method and apparatus of application |
| CN108345542A (en) * | 2018-02-28 | 2018-07-31 | 腾讯科技（深圳）有限公司 | Abnormality eliminating method and device in a kind of application program |
| CN108595187A (en) * | 2018-03-27 | 2018-09-28 | 北京美好人生伙伴信息技术有限公司 | Method, device and the storage medium of Android installation kit integrated software development kit |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP2354993A1 (en) * | 2009-12-30 | 2011-08-10 | Gemalto SA | JCVM bytecode execution protection against fault attacks |
-
2018
- 2018-11-15 CN CN201811359839.9A patent/CN109508249B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105808266A (en) * | 2016-03-29 | 2016-07-27 | 广州华多网络科技有限公司 | Code operation method and device |
| CN108089870A (en) * | 2016-11-21 | 2018-05-29 | 百度在线网络技术（北京）有限公司 | For repairing the method and apparatus of application |
| CN108345542A (en) * | 2018-02-28 | 2018-07-31 | 腾讯科技（深圳）有限公司 | Abnormality eliminating method and device in a kind of application program |
| CN108595187A (en) * | 2018-03-27 | 2018-09-28 | 北京美好人生伙伴信息技术有限公司 | Method, device and the storage medium of Android installation kit integrated software development kit |
Non-Patent Citations (1)
| Title |
|---|
| 大规模移动应用第三方库自动检测和分类方法;王浩宇等;《软件学报》;20170220;第1373页至第1386页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109508249A (en) | 2019-03-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109643270B (en) | Method and system for multi-layer test suite generation | |
| US10481964B2 (en) | Monitoring activity of software development kits using stack trace analysis | |
| US10592237B2 (en) | Efficient detection of architecture related bugs during the porting process | |
| US10171315B2 (en) | Orchestration process template for generation of orchestration process to tolerate errors | |
| US11762763B2 (en) | Orchestration for automated performance testing | |
| CN109508249B (en) | Crash processing method and device and electronic equipment | |
| AU2021206497B2 (en) | Method and apparatus for authority control, computer device and storage medium | |
| CN111221550B (en) | Rule updating method and device for streaming computing and streaming computing system | |
| US20150074657A1 (en) | Runtime detection of software configurations and upgrades | |
| US20070074172A1 (en) | Software problem administration | |
| CN113835713B (en) | Source code packet downloading method, device, computer equipment and storage medium | |
| CN111352631B (en) | Interface compatibility detection method and device | |
| CN116578282A (en) | Code generation method, device, electronic equipment and medium | |
| US9720807B2 (en) | Using core files to develop diagnostic programs | |
| CN112379973B (en) | Heavy load method and device | |
| US20200142689A1 (en) | System And Methods for Patch Management | |
| CN112506781A (en) | Test monitoring method, test monitoring device, electronic device, storage medium, and program product | |
| CN113342376B (en) | Method and device for upgrading operating system of Internet of things equipment | |
| CN113805878A (en) | Plug-in engineering method, device, computer system and medium | |
| CN110460601B (en) | Dependency package security detection method, dependency package security detection device and storage medium | |
| CN114385159A (en) | File processing method and device, electronic equipment and computer readable storage medium | |
| CN115080431A (en) | Code testing method, device, storage medium and equipment | |
| CN115328447A (en) | Business application development method and device | |
| NGUYEN et al. | Whole-system analysis for understanding publicly accessible functions in Android | |
| CN116775109A (en) | Installation package generation method, application program operation method, device, equipment and medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |