CN113535457A - Detection method, device, equipment and computer readable storage medium - Google Patents
Detection method, device, equipment and computer readable storage medium Download PDFInfo
- Publication number
- CN113535457A CN113535457A CN202111075796.3A CN202111075796A CN113535457A CN 113535457 A CN113535457 A CN 113535457A CN 202111075796 A CN202111075796 A CN 202111075796A CN 113535457 A CN113535457 A CN 113535457A
- Authority
- CN
- China
- Prior art keywords
- function
- calling
- original function
- call
- original
- 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.)
- Granted
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/0706—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 the processing taking place on a specific hardware platform or in a specific software environment
- G06F11/0715—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 the processing taking place on a specific hardware platform or in a specific software environment in a system implementing multitasking
-
- 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/079—Root cause analysis, i.e. error or fault diagnosis
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Health & Medical Sciences (AREA)
- Biomedical Technology (AREA)
- Debugging And Monitoring (AREA)
Abstract
The embodiment of the application provides a detection method, a device, equipment and a computer readable storage medium, the embodiment of the application can be applied to various scenes such as cloud technology, intelligent traffic and the like, and the detection method is executed by an Inline Hook function Inline Hook and comprises the following steps: responding to the calling of the method in the main thread triggered by the application, calling a first function corresponding to the original function converted by the method, and determining the starting time of calling the original function through the first function; calling an original function to cause an application to execute a call to a method; responding to the calling end of the original function, calling a second function corresponding to the original function, and determining the end time of calling the original function through the second function; determining the execution time period of the original function according to the starting time and the ending time; when the execution time period is greater than a preset response threshold value, determining that no response ANR exists in the application in the method calling; therefore, whether the ANR exists in the method call or not is accurately judged through the execution time period of the original function.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a detection method, apparatus, device, and computer-readable storage medium.
Background
In the prior art, there may be cases of false alarm and missing check in APP (Application) feedback of an IOS (IPhone Operating System, developed by apple inc.) (that is, there is ANR (Application Not Responding) in method call in a main thread of APP). For example, based on a monitoring scheme of FPS (frameperssecond, frames per second), when the APP is stuck, the FPS may significantly slide down, but special scenes such as transition animation also have the condition of FPS sliding down, thereby causing false alarm. For another example, with the APP-based main thread ping-pong/pong scheme, the main thread is blocked until the pong reply is not received during idle, but the stack acquired during the stack acquisition may not be the primary cause of the stuck. For another example, the monitoring scheme based on running the loop running may time-slice different phases, and when a certain time slice is too long, it is basically determined that the jamming occurs, but the application idle state may reside in the before waiting, which may cause a false alarm.
Disclosure of Invention
The application provides a detection method, a detection device, a detection apparatus and a computer-readable storage medium for overcoming the defects of the existing method, so as to solve the problem of how to improve the accuracy of judging whether ANR exists in method calling.
In a first aspect, the present application provides a detection method, which is performed by an Inline Hook function Inline Hook, and includes:
responding to the calling of the method in the main thread triggered by the application, calling a first function corresponding to the original function converted by the method, and determining the starting time of calling the original function through the first function;
calling an original function to cause an application to execute a call to a method;
responding to the calling end of the original function, calling a second function corresponding to the original function, and determining the end time of calling the original function through the second function;
determining the execution time period of the original function according to the starting time and the ending time;
and when the execution time period is greater than a preset response threshold, determining that no response ANR exists in the application in the method call.
In one embodiment, before calling the first function corresponding to the original function converted by the method, the method further includes:
and storing the context information before the original function call to a preset storage area, wherein the context information before the original function call comprises the contents of all registers in the mobile operating system before the original function call and parameters in a stack of the mobile operating system.
In one embodiment, before saving the context information before the original function call to the preset storage area, the method further includes:
saving the connection register LR and the frame pointer of the mobile operating system into the stack, and saving the parameters of the original function exceeding the number of the temporary registers into the stack.
In one embodiment, after calling the first function corresponding to the original function converted by the method, the method further includes:
and restoring the context information before the original function call in the storage area to the stack.
In one embodiment, after the original function is called, the method further includes:
determining context information after the original function call, and storing the context information after the original function call to a preset storage area, wherein the context information after the original function call comprises the contents of all registers in a mobile operating system after the original function call and parameters in a stack of the mobile operating system.
In one embodiment, the original function is an engine objc _ msgSend function and the method is a static library or system function.
In one embodiment, when an application triggers a call to at least two methods in a main thread, and a call relationship exists between the at least two methods, an exception is thrown by any one of the at least two methods, and a second function corresponding to any one method is the same as second functions corresponding to methods other than any one method, a first function corresponding to methods other than any one method is determined by moving an LR of an operating system, and the first function corresponding to any one method is discarded.
In a second aspect, the present application provides a detection apparatus, which is implemented by Inline Hook, and includes:
the first processing module is used for responding to calling of a method in a main thread triggered by an application, calling a first function corresponding to an original function converted by the method, and determining the starting time of calling the original function through the first function;
the second processing module is used for calling the original function so as to enable the application to execute the calling of the method;
the third processing module is used for responding to the calling end of the original function, calling a second function corresponding to the original function, and determining the end time of calling the original function through the second function;
the fourth processing module is used for determining the execution time period of the original function according to the starting time and the ending time;
and the fifth processing module is used for determining that the application does not respond to the ANR when the execution time period is greater than the preset response threshold.
In a third aspect, the present application provides an electronic device, comprising: a processor, a memory, and a bus;
a bus for connecting the processor and the memory;
a memory for storing operating instructions;
and the processor is used for executing the detection method of the first aspect of the application by calling the operation instruction.
In a fourth aspect, the present application provides a computer-readable storage medium storing a computer program for performing the detection method of the first aspect of the present application.
The technical scheme provided by the embodiment of the application at least has the following beneficial effects:
determining a starting time for calling the original function and an ending time for calling the original function through the Inline Hook, and determining an execution time period of the original function according to the starting time and the ending time; when the execution time period is greater than a preset response threshold, namely the calling time consumption of the method in the main thread is greater than the preset response threshold, determining that ANR exists in the method calling; therefore, the calling time of the method in the main thread, namely the execution time period of the original function, is determined through the Inline Hook, whether the ANR exists in the method calling is accurately judged, and therefore the accuracy of judging whether the ANR exists in the method calling is improved.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings used in the description of the embodiments of the present application will be briefly described below.
Fig. 1 is a schematic diagram of a system architecture provided in an embodiment of the present application;
fig. 2 is a schematic flowchart of a detection method according to an embodiment of the present disclosure;
FIG. 3 is a schematic diagram of a detection method provided in an embodiment of the present application;
FIG. 4 is a schematic diagram of a detection method provided in an embodiment of the present application;
fig. 5 is a schematic flow chart of another detection method provided in the embodiment of the present application;
fig. 6 is a schematic structural diagram of a detection apparatus according to an embodiment of the present disclosure;
fig. 7 is a schematic structural diagram of an electronic device according to an embodiment of the present application.
Detailed Description
In order to make the objects, features and advantages of the present invention more apparent and understandable, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application, and it is apparent that the described embodiments are only a part of the embodiments of the present application, and not all the embodiments of the present 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.
Reference will now be made in detail to embodiments of the present application, examples of which are illustrated in the accompanying drawings, wherein like or similar reference numerals refer to the same or similar elements or elements having the same or similar function throughout. The embodiments described below with reference to the drawings are exemplary only for the purpose of explaining the present application and are not to be construed as limiting the present application.
As used herein, the singular forms "a", "an", "the" and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms "comprises" and/or "comprising," when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. It will be understood that when an element is referred to as being "connected" or "coupled" to another element, it can be directly connected or coupled to the other element or intervening elements may also be present. Further, "connected" or "coupled" as used herein may include wirelessly connected or wirelessly coupled. As used herein, the term "and/or" includes all or any element and all combinations of one or more of the associated listed items.
The embodiment of the application provides a detection method aiming at the field of cloud education, and the detection method relates to various fields of cloud technology, such as cloud computing, cloud service and the like in the cloud technology.
Cloud Computing reduction (CCEDU) refers to an Education platform service based on Cloud Computing business model application. On the cloud platform, all education institutions, training institutions, enrollment service institutions, propaganda institutions, industry associations, management institutions, industry media, legal structures and the like are integrated into a resource pool in a centralized cloud mode, all resources are mutually displayed and interacted and communicated according to needs to achieve intentions, so that education cost is reduced, and efficiency is improved.
Cloud computing (cloud computing) is a computing model that distributes computing tasks over a pool of resources formed by a large number of computers, enabling various application systems to obtain computing power, storage space, and information services as needed. The network that provides the resources is referred to as the "cloud". Resources in the "cloud" appear to the user as being infinitely expandable and available at any time, available on demand, expandable at any time, and paid for on-demand.
As a basic capability provider of cloud computing, a cloud computing resource pool (called as an ifas (Infrastructure as a Service) platform for short is established, and multiple types of virtual resources are deployed in the resource pool and are selectively used by external clients.
According to the logic function division, a PaaS (Platform as a Service) layer can be deployed on an IaaS (Infrastructure as a Service) layer, a SaaS (Software as a Service) layer is deployed on the PaaS layer, and the SaaS can be directly deployed on the IaaS. PaaS is a platform on which software runs, such as a database, a web container, etc. SaaS is a variety of business software, such as web portal, sms, and mass texting. Generally speaking, SaaS and PaaS are upper layers relative to IaaS.
So-called artificial intelligence cloud services are also commonly referred to as AIaaS (AIas a Service, chinese "AI as a Service"). The method is a service mode of an artificial intelligence platform, and particularly, the AIaaS platform splits several types of common AI services and provides independent or packaged services at a cloud. This service model is similar to the one opened in an AI theme mall: all developers can access one or more artificial intelligence services provided by the platform through an API (application programming interface), and part of the qualified developers can also use an AI framework and an AI infrastructure provided by the platform to deploy and operate and maintain the self-dedicated cloud artificial intelligence services.
Artificial Intelligence (AI) is a theory, method, technique and application system that uses a digital computer or a machine controlled by a digital computer to simulate, extend and expand human Intelligence, perceive the environment, acquire knowledge and use the knowledge to obtain the best results. In other words, artificial intelligence is a comprehensive technique of computer science that attempts to understand the essence of intelligence and produce a new intelligent machine that can react in a manner similar to human intelligence. Artificial intelligence is the research of the design principle and the realization method of various intelligent machines, so that the machines have the functions of perception, reasoning and decision making.
The artificial intelligence technology is a comprehensive subject and relates to the field of extensive technology, namely the technology of a hardware level and the technology of a software level. The artificial intelligence infrastructure generally includes technologies such as sensors, dedicated artificial intelligence chips, cloud computing, distributed storage, big data processing technologies, operation/interaction systems, mechatronics, and the like. The artificial intelligence software technology mainly comprises a computer vision technology, a voice processing technology, a natural language processing technology, machine learning/deep learning, automatic driving, intelligent traffic and the like.
For better understanding and description of the embodiments of the present application, some technical terms used in the embodiments of the present application will be briefly described below.
Hook: hook refers to using a custom function to cover; hook is actually a program segment for processing messages, and the program segment is hung in a system through system call; each time a specific message is sent, before a destination window is not reached, the hook program captures the message, namely, the hook function obtains control right first, the hook function can process the message, can continue to deliver the message without processing, and can forcibly end delivery of the message.
Dynamic Hook: means that Hook is completed during the program running process.
Inline Hook: by modifying the primitive function part instruction, a jump or other instruction is used to reach the purpose of Hook.
SP: SP (stack pointer) indicates the top of the current stack frame.
FP: FP (FramePoint) represents the bottom of the current stack frame.
Stack Frame (Stack Frame): each function call maintains a separate stack frame on the call stack (call stack), each separate stack frame typically including: return addresses and parameters of functions; temporary variables, wherein the temporary variables include non-static local variables of functions and other temporary variables automatically generated by a compiler; context of function call. The stack extends from a high address to a low address, a stack frame of a function is defined by two registers of ebp and esp, wherein ebp points to the bottom of the current stack frame, and esp always points to the top of the stack frame; the ebp register is also called FP (frame pointer) and the esp register is also called SP (stack pointer).
ANR: ANR (Application Not Responding ) is usually a time consuming operation performed by the main thread, and the Application cannot respond to a user event.
CFA: CFA (Canonical Frame Address) refers to the stack pointer value at the call point in the caller stack Frame. The CFA represents a base address for a starting address that is the other address in the current function, so that the other address can be represented with an offset from the base address.
Fishhook: fishhook is a tool for dynamically modifying the link Mach-O file; and the Fishhook achieves the purpose of the C function HOOK by modifying two table pointers of lazy loading and non-lazy loading by using a Mach-O file loading principle.
The method comprises the following steps: the method can be a generic method, which can be classified into a public method, a private method, a generic method, a static method, and the like; wherein, the public method comprises the following steps: methods that can be called both in and out of class; the private method comprises the following steps: the method can not be called by class outside, and the method is a private method by adding double underlines in front of the method; the method comprises the following steps: the function processed by the classpathod () function can be called by the class and also can be called by the object; the static method comprises the following steps: equivalent to a global function, can be called directly by a class, can be shared by all instantiated objects, and has no self parameter for static methods defined by a static method () function.
The main thread: the main thread is that when a program is started, a process is created by an operating system, and meanwhile, a thread runs immediately; the main thread is executed when the program starts, if the thread needs to be created again, the created thread is the sub-thread of the main thread, and each process at least has one main thread; the importance of the main thread is embodied in two aspects: 1. the main thread is a thread which generates other sub-threads; 2. typically the main thread must eventually complete execution, e.g., perform various shutdown actions.
objc _ msgSend: the objc _ msgSend function is a core engine for all OC method calls, and the objc _ msgSend is responsible for finding the real class or the realization of the object method and executing the method functions. All OC method calls translate to calls to the C function obj C _ msgSend at compile time.
The IOS is written in OC language, obj _ msgSend is a core function in OC, all the method calls are finally converted into calls of an obj _ msgSend function, the prototype of the obj _ msgSend function is obj _ msgSend (id self, SELop.), the first is an object example for receiving messages, and the second parameter is a method to be executed. In order to optimize the performance of the IOS, the function is internally implemented by assembly language, and different platforms correspond to different assembly files. The IOS real machine is written by using ARM64 assembly, ARM64 has 32 general registers with the length of 64 bits: x 0-x 30 and SP, only 32 bits of each general register 64bit can be used: w 0-w 30, wherein the first 8 registers x 0-x 7 are used for transferring parameters during function call, and the x0 register can also be used as a register of function return value. The x8 register is used for indirect addressing (when the contents of a function return >16Bytes, the return is placed into memory and the memory address is then stored in the x8 register). The special registers are as follows:
(1) the SP register points to the top of the stack (low address) of the current stack frame and may allocate or release memory space for the stack by moving the position of the SP.
(2) x29 generally acts as a FP register, pointing to the bottom of the stack (high address) of the current stack frame.
(3) x30 is commonly referred to as LR (Link Register), which has two roles: 1. save subroutine return address, 2, when exception occurs, is used to save exception return address.
(4) PC, program counter, used for pointing to the next instruction.
In the IOS, when the number of parameters of the function exceeds the number of temporary registers (x 0-x 7), redundant parameters are put in a stack for storage, for example, when the number of parameters of the function exceeds 8, redundant parameters are put in the stack for storage; so in Hookobjc _ msgSend, the register cannot be saved directly in the stack and may be overwritten. The stack structure in the IOS is divided into a plurality of stack frames (frames), each stack frame corresponds to a function call, a stack pointer SP represents the top of the current stack, and the SP is the minimum value of the stack address because the stack of the IOS system grows downwards. The frame pointer FP represents the bottom of the current stack frame, the address pointed by FP stores the return address of the previous stack frame and FP, and when Hook is performed on obj _ msgSend, the previous stack frame needs to be copied to store the context of the function, so as to prevent the parameter of the function from being lost.
The technical scheme provided by the embodiment of the present application relates to a cloud technology, and the following detailed description is provided on the technical scheme of the present application and how to solve the technical problem in the technical scheme of the present application with specific embodiments. The following several specific embodiments may be combined with each other, and details of the same or similar concepts or processes may not be repeated in some embodiments. Embodiments of the present application will be described below with reference to the accompanying drawings.
The scheme provided by the embodiment of the application can be suitable for any application scene in which whether ANR exists in method invocation in a main thread needs to be detected in the technical field of cloud, and the following detection can be performed on the method invocation in the main thread through the scheme: and determining the time consumption for calling the method in the main thread through the Inline Hook, and accurately detecting whether the ANR exists in the method calling.
In order to better understand the scheme provided by the embodiment of the present application, the scheme is described below with reference to a specific application scenario.
In an embodiment, fig. 1 shows a schematic diagram of a system architecture of a detection to which the embodiment of the present application is applied, and it can be understood that the detection method provided by the embodiment of the present application can be applied to, but is not limited to, the application scenario shown in fig. 1.
In this example, as shown in fig. 1, the detected system architecture in this example may include, but is not limited to, the server 110 and the terminal 120, and the server 110 and the terminal 120 may interact with each other through a network. When the application of the IOS of the terminal 120 triggers the call of the method in the main thread, the Inline Hook running in the server 110 calls a first function corresponding to the original function converted from the method, so as to determine the starting time of calling the original function through the first function; the Inline Hook calls an original function to cause the application to execute the call to the method; responding to the calling end of the original function by the Inline Hook, calling a second function corresponding to the original function, and determining the end time of calling the original function through the second function; determining an execution time period of the original function according to the starting time and the ending time by the Inline Hook; when the execution time period is greater than a preset response threshold, the Inline Hook determines that ANR exists in the method call.
It is understood that the above is only an example, and the present embodiment is not limited thereto.
The terminal 120 may be a smart phone (e.g., an Android phone, an iOS phone, etc.), a phone simulator, a tablet computer, a notebook computer, a digital broadcast receiver, an MID (Mobile Internet Devices), a PDA (personal digital assistant), a desktop computer, a vehicle terminal (e.g., a vehicle navigation terminal), a smart speaker, a smart watch, etc. The server 110 may be an independent physical server, a server cluster or a distributed system formed by a plurality of physical servers, or a cloud server or a server cluster providing basic cloud computing services such as a cloud service, a cloud database, cloud computing, a cloud function, cloud storage, a web service, cloud communication, a middleware service, a domain name service, a security service, a CDN (Content Delivery Network), a big data and artificial intelligence platform, and the like. Such networks may include, but are not limited to: a wired network, a wireless network, wherein the wired network comprises: a local area network, a metropolitan area network, and a wide area network, the wireless network comprising: bluetooth, Wi-Fi, and other networks that enable wireless communication. The determination may also be based on the requirements of the actual application scenario, and is not limited herein.
Referring to fig. 2, fig. 2 shows a schematic flow chart of a detection method provided in an embodiment of the present application, as an alternative implementation, the method may be executed by Inline Hook, and for convenience of description, in the following description of some alternative embodiments, the Inline Hook is taken as an example of an execution subject of the method to be described. As shown in fig. 2, the detection method provided in the embodiment of the present application includes the following steps:
s101, responding to the calling of the method in the main thread triggered by the application, calling a first function corresponding to the original function converted by the method, and determining the starting time of calling the original function through the first function.
In one embodiment, an application of the IOS triggers a call to a method in a main thread, the application converts the call to the method in the main thread into a call to an original function, and the Inline Hook calls a first function corresponding to the original function. For example, the original function may be an objc _ msgSend function, the Inline Hook calls a first function corresponding to the objc _ msgSend function, the first function is a before _ objc _ msgSend function, and the before _ objc _ msgSend function is used to record a start time, i.e., a start time, when the Inline Hook calls the objc _ msgSend function.
In one embodiment, before calling the first function corresponding to the original function converted by the method, the method further includes:
and storing the context information before the original function call to a preset storage area, wherein the context information before the original function call comprises the contents of all registers in the mobile operating system before the original function call and parameters in a stack of the mobile operating system.
In one embodiment, the storage area may be a preset temporary space. The context information prior to the original function call may be the context environment prior to the original function call. The context before the original function call includes the contents of all registers in the mobile operating system IOS before the original function call, as well as parameters in the stack of the IOS before the original function call. For example, the contents of all registers in the mobile operating system IOS before the original function call may include: the content of the first 32 general registers with the length of 64 bits is called by the original function, wherein the 32 general registers are x 0-x 30 and SP.
In one embodiment, before saving the context information before the original function call to the preset storage area, the method further includes:
the LR (Link Register) and the frame pointer of the mobile operating system are saved to the stack, and the parameter exceeding the number of temporary registers of the original function is saved to the stack.
In one embodiment, when the number of parameters of the original function exceeds the number of temporary registers, the exceeded parameters are put on a stack for saving. For example, the temporary registers are registers x 0-x 7, the number of the registers x 0-x 7 is 8, and when the number of the parameters 10 of the original function exceeds 8, the 2 exceeded parameters are put into a stack for storage.
In one embodiment, after calling the first function corresponding to the original function converted by the method, the method further includes:
and restoring the context information before the original function call in the storage area to the stack.
In one embodiment, the storage area may be a preset temporary space. The context information prior to the original function call may be the context environment prior to the original function call. And restoring the context environment before the original function call from the temporary space by the Inline Hook, namely restoring the context environment before the original function call in the temporary space to the stack. The context before the original function call includes the contents of all registers in the mobile operating system IOS before the original function call, as well as parameters in the stack of the IOS before the original function call. For example, the contents of all registers may include: the content of the first 32 general registers with the length of 64 bits is called by the original function, wherein the 32 general registers are x 0-x 30 and SP.
In one embodiment, the Inline Hook calls the original function, e.g., the original function is an obj c _ msgSend function, after restoring the context information in the memory area before the original function call to the stack.
S102, calling the original function so that the application executes the calling of the method.
In one embodiment, the Inline Hook calls the original function, for example, the objc _ msgSend function, to enable the application to call a method in the main thread.
In one embodiment, after the original function is called, the method further includes:
determining context information after the original function call, and storing the context information after the original function call to a preset storage area, wherein the context information after the original function call comprises the contents of all registers in a mobile operating system after the original function call and parameters in a stack of the mobile operating system.
In one embodiment, the storage area may be a preset temporary space. The context information after the original function call may be the context environment after the original function call. The context environment after the original function call includes the contents of all registers in the mobile operating system IOS after the original function call, and parameters in the stack of the IOS after the original function call. For example, the contents of all registers in the mobile operating system IOS after the original function call may include: and after the original function is called, the contents of 32 general registers with the length of 64 bits are obtained, wherein the 32 general registers are x 0-x 30 and SP respectively.
And S103, responding to the calling end of the original function, calling a second function corresponding to the original function, and determining the end time of calling the original function through the second function.
In one embodiment, when the process of calling the original function by the Inline Hook is finished, the Inline Hook calls a second function corresponding to the original function. For example, the original function may be an objc _ msgSend function, the Inline Hook calls a second function corresponding to the objc _ msgSend function, the second function is an after _ objc _ msgSend function, and the after _ objc _ msgSend function is used to record an end time, that is, an end time, when the Inline Hook calls the objc _ msgSend function.
In one embodiment, the value of LR is used as a parameter of the second function corresponding to the original function for determining the first function corresponding to the original function.
For example, the value of LR is used as a parameter of an after _ obj _ msgSend function corresponding to a certain original function, that is, the value of LR is assigned to the general register x2 for determining the before _ obj _ msgSend function corresponding to the original function.
In one embodiment, when the application triggers the call of at least two methods in the main thread, a call relation exists between the at least two methods, and any method in the at least two methods throws an exception, a first function corresponding to the method except for any method is determined through an LR of the IOS.
In one embodiment, when an application triggers a call to at least two methods in a main thread, and a call relationship exists between the at least two methods, an exception is thrown by any one of the at least two methods, and a second function corresponding to any one method is the same as second functions corresponding to methods other than any one method, a first function corresponding to methods other than any one method is determined by moving an LR of an operating system, and the first function corresponding to any one method is discarded.
In one embodiment, when an application triggers the call of any two methods (method a and method B) in a main thread, a call relationship exists between the two methods, and a method B in the two methods throws an exception, and a second function corresponding to the method a is the same as a second function corresponding to the method B, that is, the second function corresponds (is associated with) a first function corresponding to the method a and a first function corresponding to the method B at the same time; then it is determined by the LR of the IOS that the second function should correspond to the first function corresponding to method a and the second function should not correspond to the first function corresponding to method B, so that the first function corresponding to the second function is correctly determined.
For example, the call to the multiple methods in the main thread is actually a call to the original functions corresponding to the methods. As shown in fig. 3, the original function corresponding to the method a is an a function, the a function is an obj _ msgSend function, the first function corresponding to the a function is a before _ obj _ msgSend function corresponding to the a function, and the second function corresponding to the a function is an after _ obj _ msgSend function corresponding to the a function; the original function corresponding to the method B is a function B, the function B is an obj _ msgSend function, the first function corresponding to the function B is a before _ obj _ msgSend function corresponding to the function B, and the second function corresponding to the function B is an after _ obj _ msgSend function corresponding to the function B. Other functions in the main thread call the A function, and the A function calls the B function. The calling of the B function by the A function can trigger the calling of the before _ obj _ msgSend function and the B function corresponding to the B function by the Inline Hook and the calling of the after _ obj _ msgSend function corresponding to the B function.
When the B function does not have a crash (exception), the order of the entire data stream is: sequence 1, sequence 2, sequence 3, sequence 4, sequence 5, and sequence 6; the sequence 1 is to call a function before _ obj _ msgSend corresponding to the a function, the sequence 2 is to call the a function, the sequence 3 is to call a function before _ obj _ msgSend corresponding to the B function, the sequence 4 is to call a function B, the sequence 5 is to call an after _ obj _ msgSend corresponding to the B function, and the sequence 6 is to call an after _ obj _ msgSend corresponding to the a function. Determining the calling time consumption of the A function according to the after _ obj _ msgSend function corresponding to the A function and the before _ obj _ msgSend function corresponding to the A function, namely performing difference calculation between the after _ obj _ msgSend function corresponding to the A function and the before _ obj _ msgSend function corresponding to the A function to obtain the calling time consumption of the A function; and determining the calling time consumption of the B function according to the after _ obj _ msgSend function corresponding to the B function and the before _ obj _ msgSend function corresponding to the B function, namely performing difference calculation between the after _ obj _ msgSend function corresponding to the B function and the before _ obj _ msgSend function corresponding to the B function to obtain the calling time consumption of the B function.
When the B function has a crash (exception), that is, the try-catch function captures the crash of the B function, the order of the whole data stream is: sequence 1, sequence 2, sequence 3, sequence 7, and sequence 6; wherein, the sequence 1 is to call the before _ obj _ msgSend function corresponding to the a function, the sequence 2 is to call the a function, the sequence 3 is to call the before _ obj _ msgSend function corresponding to the B function, the sequence 7 is to call the B function, and the sequence 6 is to call the after _ obj _ msgSend function corresponding to the a function. The after _ obj _ msgSend function corresponding to the B function is not called actually, but the after _ obj _ msgSend function corresponding to the a function is called directly, at this time, the before _ obj _ msgSend function corresponding to the B function is associated with the after _ obj _ msgSend function corresponding to the a function, so that the after _ obj _ msgSend function corresponding to the a function is associated with the before _ obj _ msgSend function corresponding to the a function and the before _ obj _ msgSend function corresponding to the B function at the same time, that is, the second function corresponding to the B function is the same as the second function corresponding to the a function, and the second function corresponding to the B function and the a function are both the after _ obj _ msgSend function corresponding to the a function. Therefore, as shown in fig. 4, the value of LR is used as a parameter of the after _ obj _ msgSend function corresponding to the a function, and is used to determine that the after _ obj _ msgSend corresponding to the a function should be associated with the before _ obj _ msgSend function of the a function, and discard the before _ obj _ msgSend function corresponding to the B function, thereby avoiding a calculation error of the call elapsed time caused by associating the after _ obj _ msgSend corresponding to the a function with the before _ obj _ msgSend function corresponding to the B function.
And S104, determining the execution time period of the original function according to the starting time and the ending time.
In one embodiment, a difference calculation is performed between the end time and the start time to obtain an execution time period of the original function, wherein the execution time period of the original function is the time consumed by calling the original function.
And S105, when the execution time period is greater than a preset response threshold, determining that no response ANR exists in the application in the method call.
For example, the preset response threshold may be taken as 100ms (millisecond), and when the time taken for calling the original function is greater than 100ms, it is determined that the ANR exists in the method call of the APP, and the original function generating the ANR can be accurately captured.
In one embodiment, the original function is an engine objc _ msgSend function and the method is a static library or system function.
It should be noted that Fishhook is limited and cannot be used to Hook static libraries and system functions. The static library and the system function can be converted into an original function, and the Inline Hook can detect the calling time consumption of the static library and the system function.
In the embodiment of the application, the starting time for calling the original function and the ending time for calling the original function are determined through the Inline Hook, and the execution time period of the original function is determined according to the starting time and the ending time; when the execution time period is greater than a preset response threshold, namely the calling time consumption of the method in the main thread is greater than the preset response threshold, determining that ANR exists in the method calling; therefore, the calling time of the method in the main thread, namely the execution time period of the original function, is determined through the Inline Hook, whether the ANR exists in the method calling is accurately judged, and therefore the accuracy of judging whether the ANR exists in the method calling is improved.
In order to better understand the method provided by the embodiment of the present application, the following further describes the scheme of the embodiment of the present application with reference to an example of a specific application scenario.
Referring to fig. 5, fig. 5 shows a schematic flow chart of a detection method provided in an embodiment of the present application, as an alternative implementation, the method may be executed by Inline Hook, and for convenience of description, in the following description of some alternative embodiments, the Inline Hook is taken as an example of an execution subject of the method to be described. As shown in fig. 5, the detection method provided in the embodiment of the present application includes the following steps:
s201, saving the connection register LR and the frame pointer FP of the IOS into the stack of the IOS.
S202, copying stack frames of the IOS, and saving parameters of the original function exceeding the number of the temporary registers in a stack.
In one embodiment, when the number of the parameters of the original function exceeds the number of the temporary registers, the parameters exceeding the number of the temporary registers are saved in a stack; parameters exceeding the number of temporary registers may be copied down by copying stack frames of the IOS. For example, the temporary registers are registers x 0-x 7, the number of the registers x 0-x 7 is 8, when the number of the parameters 15 of the original function exceeds 8, the exceeded 7 parameters are put in a stack for storage, and the exceeded 7 parameters can be copied by copying the stack frame of the IOS.
S203, resetting the CFA and tracing back to the top layer of the stack through the standard CFA.
For example, a function calls a function B, and a function B calls a function C; and resetting the CFA, and repeatedly assigning values of w 29-w 30 through the specification of the CFA, so that the top layer of the stack can be traced all the way, namely the C function is traced all the way to the A function.
And S204, storing the context environment before the original function is called.
In one embodiment, the context before the original function call is saved to a preset temporary space, and the context before the original function call includes the contents of all registers in the IOS before the original function call and parameters in the stack of the IOS. For example, the contents of all registers in the IOS prior to the original function call may include: the content of the first 32 general registers with the length of 64 bits is called by the original function, wherein the 32 general registers are x 0-x 30 and SP.
S205, calling a before _ obj _ msgSend function corresponding to the original function, and recording the starting time of calling the original function.
For example, the original function may be an objc _ msgSend function, the Inline Hook calls a first function corresponding to the objc _ msgSend function, the first function is a before _ objc _ msgSend function, and the before _ objc _ msgSend function is used to record a start time, i.e., a start time, when the Inline Hook calls the objc _ msgSend function.
S206, restoring the context environment in the temporary space before the original function call to the stack.
In one embodiment, the Inline Hook restores the context before the original function call in the temporary space to the stack. The context before the original function call includes the contents of all registers in the IOS before the original function call, as well as parameters in the stack of the IOS before the original function call. For example, the contents of all registers may include: the content of the first 32 general registers with the length of 64 bits is called by the original function, wherein the 32 general registers are x 0-x 30 and SP.
S207, calling the original function.
In one embodiment, the original function objc _ msgSend is called by the Inline Hook, thereby enabling the application to call the method in the main thread.
And S208, storing the context environment after the original function is called.
In one embodiment, the context environment after the original function call is saved to the temporary space, and the context information after the original function call includes the contents of all registers in the IOS after the original function call and parameters in the stack of the IOS. For example, the contents of all registers in the IOS after the original function call may include: and after the original function is called, the contents of 32 general registers with the length of 64 bits are obtained, wherein the 32 general registers are x 0-x 30 and SP respectively.
S209, calling the after _ obj _ msgSend function corresponding to the original function, for recording the end time of calling the original function.
In one embodiment, when the process of calling the original function by the Inline Hook is finished, the Inline Hook calls a second function corresponding to the original function. For example, the original function may be an objc _ msgSend function, the Inline Hook calls a second function corresponding to the objc _ msgSend function, the second function is an after _ objc _ msgSend function, and the after _ objc _ msgSend function is used to record an end time, that is, an end time, when the Inline Hook calls the objc _ msgSend function. And taking the value of the LR as a parameter of a second function corresponding to the original function, so as to be used for determining a first function corresponding to the original function. For example, the value of LR is used as a parameter of the after _ obj _ msgSend function corresponding to the original function, that is, the value of LR is assigned to the general register x2 for determining the before _ obj _ msgSend function corresponding to the original function.
And S210, calculating the difference between the ending time and the starting time to obtain the calling time consumption of the original function.
S211, when the calling time consumption of the original function is larger than a preset response threshold, determining that ANR exists in the method calling of the APP.
In one embodiment, when the calling time of the original function is not greater than a preset response threshold, it is determined that the ANR does not exist in the method calling of the APP.
S212, restoring the context environment after the original function call in the temporary space to the stack.
In one embodiment, the Inline Hook restores the context after the original function call in temporary space to the stack. The context environment after the original function call includes the contents of all registers in the IOS after the original function call, and parameters in the stack of the IOS after the original function call. For example, the contents of all registers in the IOS after the original function call may include: and after the original function is called, the contents of 32 general registers with the length of 64 bits are obtained, wherein the 32 general registers are x 0-x 30 and SP respectively.
S213, releasing the LR, FP and stack frames stored in the IOS stack.
In the embodiment of the application, the calling time consumption of all functions (methods) of the main thread is monitored through the Inline Hook, when the ANR occurs in the function calling of the APP, the function generating the ANR can be accurately captured, and the possibility of false alarm and false alarm omission does not exist.
Based on the same inventive concept, the embodiment of the present application further provides a detection apparatus, the detection apparatus is implemented by an Inline Hook, a schematic structural diagram of the apparatus is shown in fig. 6, and the detection apparatus 40 includes a first processing module 401, a second processing module 402, a third processing module 403, a fourth processing module 404, and a fifth processing module 405.
A first processing module 401, configured to, in response to a call to a method in a main thread triggered by an application, call a first function corresponding to an original function converted from the method, so as to determine, by the first function, a start time for calling the original function;
a second processing module 402, configured to call an original function, so that the application executes a call to a method;
a third processing module 403, configured to, in response to the end of the call to the original function, call a second function corresponding to the original function, so as to determine, by the second function, an end time of the call to the original function;
a fourth processing module 404, configured to determine an execution time period of the original function according to the starting time and the ending time;
a fifth processing module 405, configured to determine that the method exists that the application does not respond to the ANR when the execution time period is greater than the preset response threshold.
In one embodiment, before calling the first function corresponding to the original function converted by the method, the first processing module 401 is further configured to:
and storing the context information before the original function call to a preset storage area, wherein the context information before the original function call comprises the contents of all registers in the mobile operating system before the original function call and parameters in a stack of the mobile operating system.
In an embodiment, before saving the context information before the original function call to the preset storage area, the first processing module 401 is further configured to:
saving the connection register LR and the frame pointer of the mobile operating system into the stack, and saving the parameters of the original function exceeding the number of the temporary registers into the stack.
In one embodiment, the first processing module 401 is further configured to:
and restoring the context information before the original function call in the storage area to the stack.
In one embodiment, after the original function is called, the second processing module 402 is further configured to:
determining context information after the original function call, and storing the context information after the original function call to a preset storage area, wherein the context information after the original function call comprises the contents of all registers in a mobile operating system after the original function call and parameters in a stack of the mobile operating system.
In one embodiment, the original function is an engine objc _ msgSend function and the method is a static library or system function.
In one embodiment, the first processing module 401 is further configured to:
when the application triggers the calling of at least two methods in the main thread, a calling relation exists between the at least two methods, any method in the at least two methods throws an exception, and a second function corresponding to any method is the same as second functions corresponding to other methods except any method, a first function corresponding to other methods except any method is determined through the LR of the mobile operating system, and the first function corresponding to any method is discarded.
The application of the embodiment of the application has at least the following beneficial effects:
determining a starting time for calling the original function and an ending time for calling the original function through the Inline Hook, and determining an execution time period of the original function according to the starting time and the ending time; when the execution time period is greater than a preset response threshold, namely the calling time consumption of the method in the main thread is greater than the preset response threshold, determining that ANR exists in the method calling; therefore, the calling time of the method in the main thread, namely the execution time period of the original function, is determined through the Inline Hook, whether the ANR exists in the method calling is accurately judged, and therefore the accuracy of judging whether the ANR exists in the method calling is improved.
Based on the same inventive concept, the embodiment of the present application further provides an electronic device, a schematic structural diagram of which is shown in fig. 7, where the electronic device 9000 includes at least one processor 9001, a memory 9002, and a bus 9003, and at least one processor 9001 is electrically connected to the memory 9002; the memory 9002 is configured to store at least one computer executable instruction, and the processor 9001 is configured to execute the at least one computer executable instruction to perform the steps of any of the detection methods as provided by any of the embodiments or any of the alternative embodiments of the present application.
Further, the processor 9001 may be an FPGA (Field-Programmable Gate Array) or other devices with logic processing capability, such as an MCU (micro controller Unit) and a CPU (Central processing Unit).
The application of the embodiment of the application has at least the following beneficial effects:
determining a starting time for calling the original function and an ending time for calling the original function through the Inline Hook, and determining an execution time period of the original function according to the starting time and the ending time; when the execution time period is greater than a preset response threshold, namely the calling time consumption of the method in the main thread is greater than the preset response threshold, determining that ANR exists in the method calling; therefore, the calling time of the method in the main thread, namely the execution time period of the original function, is determined through the Inline Hook, whether the ANR exists in the method calling is accurately judged, and therefore the accuracy of judging whether the ANR exists in the method calling is improved.
Based on the same inventive concept, the embodiments of the present application further provide a computer-readable storage medium storing a computer program, where the computer program is used to implement the steps of any one of the detection methods provided in any one of the embodiments or any one of the alternative embodiments of the present application when the computer program is executed by a processor.
The computer-readable storage medium provided by the embodiments of the present application includes, but is not limited to, any type of disk including floppy disks, hard disks, optical disks, CD-ROMs, and magneto-optical disks, ROMs (Read-Only memories), RAMs (Random Access memories), EPROMs (Erasable Programmable Read-Only memories), EEPROMs (Electrically Erasable Programmable Read-Only memories), flash memories, magnetic cards, or optical cards. That is, a readable storage medium includes any medium that stores or transmits information in a form readable by a device (e.g., a computer).
The application of the embodiment of the application has at least the following beneficial effects:
determining a starting time for calling the original function and an ending time for calling the original function through the Inline Hook, and determining an execution time period of the original function according to the starting time and the ending time; when the execution time period is greater than a preset response threshold, namely the calling time consumption of the method in the main thread is greater than the preset response threshold, determining that ANR exists in the method calling; therefore, the calling time of the method in the main thread, namely the execution time period of the original function, is determined through the Inline Hook, whether the ANR exists in the method calling is accurately judged, and therefore the accuracy of judging whether the ANR exists in the method calling is improved.
The embodiment of the present application further provides a computer program product containing instructions, which when run on a computer device, causes the computer device to execute the detection method provided by the above method embodiments.
It will be understood by those within the art 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 computer programs. Those skilled in the art will appreciate that the computer program product may be implemented by a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, implement the aspects specified in the block or blocks of the block diagrams and/or flowchart illustrations disclosed herein.
Those of skill in the art will appreciate that the various operations, methods, steps in the processes, acts, or solutions discussed in this application can be interchanged, modified, combined, or eliminated. Further, other steps, measures, or schemes in various operations, methods, or flows that have been discussed in this application can be alternated, altered, rearranged, broken down, combined, or deleted. Further, steps, measures, schemes in the prior art having various operations, methods, procedures disclosed in the present application may also be alternated, modified, rearranged, decomposed, combined, or deleted.
The foregoing is only a partial embodiment of the present application, and it should be noted that, for those skilled in the art, several modifications and decorations can be made without departing from the principle of the present application, and these modifications and decorations should also be regarded as the protection scope of the present application.
Claims (10)
1. A detection method, performed by an Inline Hook function Inline Hook, comprising:
responding to the calling of a method in a main thread triggered by an application, calling a first function corresponding to an original function converted by the method, and determining a starting moment for calling the original function through the first function;
calling the original function to cause the application to perform the call to the method;
responding to the calling end of the original function, calling a second function corresponding to the original function, and determining the end time of calling the original function through the second function;
determining the execution time period of the original function according to the starting time and the ending time;
and when the execution time period is greater than a preset response threshold, determining that no response ANR exists in the application in the method call.
2. The method of claim 1, further comprising, prior to said calling a first function corresponding to an original function into which said method is transformed:
and storing the context information before the original function call to a preset storage area, wherein the context information before the original function call comprises the contents of all registers in a mobile operating system before the original function call and parameters in a stack of the mobile operating system.
3. The method according to claim 2, wherein before saving the context information before the original function call to a preset storage area, further comprising:
saving a connection register (LR) and a frame pointer of the mobile operating system in the stack, and saving parameters exceeding the number of temporary registers of the original function in the stack.
4. The method of claim 2, further comprising, after said calling a first function corresponding to an original function into which the method was transformed:
and restoring the context information in the storage area before the original function call into the stack.
5. The method of claim 1, after said calling said original function, further comprising:
determining the context information after the original function call, and storing the context information after the original function call to a preset storage area, wherein the context information after the original function call comprises the contents of all registers in a mobile operating system after the original function call, and parameters in a stack of the mobile operating system.
6. The method of claim 1, wherein the original function is an engine objc _ msgSend function, and wherein the method is a static library or system function.
7. The method of claim 1, further comprising:
when the application triggers the calling of at least two methods in the main thread and a calling relation exists between the at least two methods, an exception is thrown out by any one of the at least two methods, and a second function corresponding to the any one method is the same as second functions corresponding to other methods except the any one method, a first function corresponding to the other methods except the any one method is determined through LR of a mobile operating system, and the first function corresponding to the any one method is discarded.
8. A detection apparatus, characterized in that the detection apparatus is implemented by an Inline Hook function Inline Hook, comprising:
the first processing module is used for responding to calling of a method in a main thread triggered by an application, calling a first function corresponding to an original function converted by the method, and determining a starting moment for calling the original function through the first function;
the second processing module is used for calling the original function so as to enable the application to execute the calling of the method;
the third processing module is used for responding to the calling end of the original function, calling a second function corresponding to the original function, and determining the end time of calling the original function through the second function;
the fourth processing module is used for determining the execution time period of the original function according to the starting time and the ending time;
and the fifth processing module is configured to determine that the method has application not responding to the ANR when the execution time period is greater than a preset response threshold.
9. An electronic device, comprising: a processor, a memory;
the memory for storing a computer program;
the processor for executing the detection method according to any one of claims 1 to 7 by calling the computer program.
10. A computer-readable storage medium, characterized in that a computer program is stored which, when being executed by a processor, is adapted to carry out the detection method according to any one of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111075796.3A CN113535457B (en) | 2021-09-14 | 2021-09-14 | Detection method, device, equipment and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111075796.3A CN113535457B (en) | 2021-09-14 | 2021-09-14 | Detection method, device, equipment and computer readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113535457A true CN113535457A (en) | 2021-10-22 |
| CN113535457B CN113535457B (en) | 2021-12-10 |
Family
ID=78092549
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111075796.3A Active CN113535457B (en) | 2021-09-14 | 2021-09-14 | Detection method, device, equipment and computer readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113535457B (en) |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107480029A (en) * | 2017-08-02 | 2017-12-15 | 北京深思数盾科技股份有限公司 | A kind of monitoring method and device of function call time |
| CN107704383A (en) * | 2017-09-12 | 2018-02-16 | 中国航空工业集团公司洛阳电光设备研究所 | A kind of dynamic test function coverage rate acquisition methods of task based access control stack analysis |
| CN108197004A (en) * | 2018-01-23 | 2018-06-22 | 武汉斗鱼网络科技有限公司 | The method of IOS applications takes, loads monitoring method and system that view takes |
| CN108228434A (en) * | 2016-12-21 | 2018-06-29 | 中国科学院信息工程研究所 | A kind of system of kernel source code grade calls tracking |
| CN108322602A (en) * | 2018-01-29 | 2018-07-24 | 努比亚技术有限公司 | A kind of method, terminal and computer readable storage medium handled using no response |
| CN109783161A (en) * | 2018-12-11 | 2019-05-21 | 北京三快在线科技有限公司 | The operation information of application program determines method, apparatus in iOS system |
| CN112860513A (en) * | 2021-01-29 | 2021-05-28 | 北京字跳网络技术有限公司 | Application non-response monitoring method, device, equipment and storage medium |
-
2021
- 2021-09-14 CN CN202111075796.3A patent/CN113535457B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108228434A (en) * | 2016-12-21 | 2018-06-29 | 中国科学院信息工程研究所 | A kind of system of kernel source code grade calls tracking |
| CN107480029A (en) * | 2017-08-02 | 2017-12-15 | 北京深思数盾科技股份有限公司 | A kind of monitoring method and device of function call time |
| CN107704383A (en) * | 2017-09-12 | 2018-02-16 | 中国航空工业集团公司洛阳电光设备研究所 | A kind of dynamic test function coverage rate acquisition methods of task based access control stack analysis |
| CN108197004A (en) * | 2018-01-23 | 2018-06-22 | 武汉斗鱼网络科技有限公司 | The method of IOS applications takes, loads monitoring method and system that view takes |
| CN108322602A (en) * | 2018-01-29 | 2018-07-24 | 努比亚技术有限公司 | A kind of method, terminal and computer readable storage medium handled using no response |
| CN109783161A (en) * | 2018-12-11 | 2019-05-21 | 北京三快在线科技有限公司 | The operation information of application program determines method, apparatus in iOS system |
| CN112860513A (en) * | 2021-01-29 | 2021-05-28 | 北京字跳网络技术有限公司 | Application non-response monitoring method, device, equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113535457B (en) | 2021-12-10 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108647051B (en) | Optimization strategy obtaining method, providing method, device and equipment | |
| JP2021503681A (en) | Generating and deploying machine learning model packages | |
| CN106127036B (en) | The worker process of duration and elasticity | |
| CN112416415A (en) | Front-end micro-service implementation method and related components | |
| CN107526623B (en) | Data processing method and device | |
| US20160306656A1 (en) | Intelligent application back stack management | |
| CN113779166A (en) | Geo-fence control method and device, storage medium and electronic equipment | |
| CN106775620B (en) | Timing method and device | |
| US11909640B2 (en) | Creating endpoints | |
| CN111049908A (en) | Data pre-caching method and device for mobile equipment | |
| CN108762983B (en) | Multimedia data recovery method and device | |
| CN113535457B (en) | Detection method, device, equipment and computer readable storage medium | |
| CN104750553B (en) | Using operation method and device | |
| CN111506393B (en) | ARM-based virtualization device and use method thereof | |
| US9489179B2 (en) | Application programming interface tracing mechanism | |
| CN114115884A (en) | Management method and related device for programming service | |
| CN114610446B (en) | Method, device and system for automatically injecting probe | |
| CN104112056A (en) | Method and system for detecting data processing faults | |
| CN115981871A (en) | GPU resource scheduling method, device, equipment and storage medium | |
| CN109684846A (en) | A kind of file extraction method and device | |
| CN116382713A (en) | Method, system, device and storage medium for constructing application mirror image | |
| CN106708737B (en) | Test method and device | |
| CN107301089B (en) | APP deployment and calling method and terminal | |
| CN114185773A (en) | Program testing method, program testing device, electronic equipment and computer readable storage medium | |
| CN116932103A (en) | Method for changing application interface and related equipment |
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 |