CN113961458A

CN113961458A - Remote interface debugging method, device, storage medium, electronic equipment and system

Info

Publication number: CN113961458A
Application number: CN202111235914.2A
Authority: CN
Inventors: 刘继玺; 周暄承
Original assignee: Beijing ByteDance Network Technology Co Ltd
Current assignee: Beijing ByteDance Network Technology Co Ltd
Priority date: 2021-10-22
Filing date: 2021-10-22
Publication date: 2022-01-21

Abstract

The disclosure relates to a remote interface debugging method, a device, a storage medium, an electronic device and a system, wherein the method comprises the following steps: generating a remote interface calling request; carrying out data processing on a calling parameter carried by a remote interface calling request to obtain interface calling protocol data, wherein the data processing is used for converting the calling parameter into protocol data supported by an SDK interface of second terminal equipment connected with the first terminal equipment according to a pre-configured first interaction protocol; and sending the interface calling protocol data to the second terminal equipment so that the second terminal equipment analyzes the interface calling protocol data and calls the second target method according to an analysis result based on a reflection mechanism. The development environment information of the first terminal equipment does not need to be packaged into a specific file and installed to the second terminal equipment to be tested, the SDK interface of the second terminal equipment can identify and analyze the interface calling protocol data, and the first terminal equipment remotely calls the SDK interface of the second terminal equipment.

Description

Remote interface debugging method, device, storage medium, electronic equipment and system

Technical Field

The present disclosure relates to the technical field of electronic information technologies, and in particular, to a method, an apparatus, a storage medium, an electronic device, and a system for remote interface debugging.

Background

In the game development technology, a game is developed on a PC (personal computer) side, and a game engine is used as a development engine to perform engineering development by using a C # programming language. When a game terminal is tested, the PC terminal is required to call an SDK (Software Development Kit) interface of the terminal to implement the test.

At present, a game engine needs to package development environment information into a specific file and install the file into a terminal to be tested, and then can call an SDK interface on the terminal, for example, if a device is an Android system, the development environment needs to be packaged into an APK (Android application package) file and installed on the device to realize remote call, which reduces the efficiency of function test and occupies a memory of the terminal.

Disclosure of Invention

This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

In a first aspect, the present disclosure provides a remote interface debugging method applied to a first terminal device, including:

generating a remote interface calling request;

performing data processing on a calling parameter carried by the remote interface calling request to obtain interface calling protocol data, wherein the data processing is used for converting the calling parameter into protocol data supported by an SDK interface of second terminal equipment connected with the first terminal equipment according to a pre-configured first interaction protocol;

and sending the interface calling protocol data to the second terminal equipment so that the second terminal equipment analyzes the interface calling protocol data, and calling a second target method according to an analysis result based on a reflection mechanism.

In a second aspect, the present disclosure provides a remote interface debugging apparatus, including:

the generating module is used for generating a remote interface calling request;

the processing module is used for carrying out data processing on the calling parameters carried by the remote interface calling request to obtain interface calling protocol data, wherein the data processing is used for converting the calling parameters into protocol data supported by an SDK interface of second terminal equipment connected with the first terminal equipment according to a pre-configured first interaction protocol;

and the sending module is used for sending the interface calling protocol data to the second terminal equipment so as to enable the second terminal equipment to analyze the interface calling protocol data and call a second target method according to an analysis result based on a reflection mechanism.

In a third aspect, the present disclosure provides a computer readable medium having stored thereon a computer program which, when executed by a processing apparatus, performs the steps of the method of the first aspect.

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

a storage device having a computer program stored thereon;

processing means for executing the computer program in the storage means to carry out the steps of the method of the first aspect.

In a fifth aspect, the present disclosure provides a remote interface debugging system, including:

the terminal device comprises a first terminal device and a second terminal device, wherein the first terminal device is used for generating a remote interface calling request, carrying out data processing on calling parameters carried by the remote interface calling request to obtain interface calling protocol data and sending the interface calling protocol data to the second terminal device connected with the first terminal device, and the data processing is used for converting the calling parameters into protocol data supported by an SDK interface of the second terminal device according to a pre-configured first interaction protocol;

and the second terminal equipment is used for analyzing the interface calling protocol data and calling a second target method according to an analysis result based on a reflection mechanism.

According to the technical scheme, the calling parameters carried in the interface calling request are subjected to data processing to obtain interface calling protocol data, and the interface calling protocol data are protocol data supported by an SDK interface of second terminal equipment connected with the first terminal equipment according to a pre-configured first interaction protocol, so that development environment information of the first terminal equipment does not need to be packaged into a specific file and is installed on the second terminal equipment to be tested, the SDK interface of the second terminal equipment can directly identify and analyze the interface calling protocol data, remote calling of the first terminal equipment to the SDK interface of the second terminal equipment is achieved, occupation of a memory of the second terminal equipment is reduced, and terminal testing efficiency is improved; and the second terminal equipment calls the second target method based on the reflection mechanism so as to dynamically acquire the second target method in the running state.

Additional features and advantages of the disclosure will be set forth in the detailed description which follows.

Drawings

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

fig. 1 is a flowchart illustrating a remote interface debugging method according to an exemplary embodiment of the present disclosure.

Fig. 2 is a flowchart illustrating a second terminal device invoking a second target method according to an exemplary embodiment of the present disclosure.

Fig. 3 is another flowchart illustrating a second terminal device invoking a second target method according to an exemplary embodiment of the present disclosure.

Fig. 4 is an interaction diagram illustrating a remote interface debugging method according to an exemplary embodiment of the present disclosure.

Fig. 5 is a block diagram illustrating a remote interface debugging apparatus according to an exemplary embodiment of the present disclosure.

Fig. 6 is a schematic structural diagram of an electronic device according to an exemplary embodiment of the present disclosure.

Detailed Description

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

It should be understood that the various steps recited in the method embodiments of the present disclosure may be performed in a different order, and/or performed in parallel. Moreover, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the present disclosure is not limited in this respect.

The term "include" and variations thereof as used herein are open-ended, i.e., "including but not limited to". The term "based on" is "based, at least in part, on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". Relevant definitions for other terms will be given in the following description.

It should be noted that the terms "first", "second", and the like in the present disclosure are only used for distinguishing different devices, modules or units, and are not used for limiting the order or interdependence relationship of the functions performed by the devices, modules or units.

It is noted that references to "a", "an", and "the" modifications in this disclosure are intended to be illustrative rather than limiting, and that those skilled in the art will recognize that "one or more" may be used unless the context clearly dictates otherwise.

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

As described in the background section, in the prior art, when a game function test is performed, only the development environment is packaged into a format file correspondingly supported by the tested terminal, and the function test can be remotely executed, which consumes much time and memory. Based on this, the present disclosure provides the following technical solutions, which effectively reduce the memory occupation of the tested terminal and improve the test efficiency of the program execution function test.

First, technical terms to which the present disclosure is applied will be explained.

Interface: the interface is an application programming interface, is a capability entry of the program exposed to the outside and shields the internal implementation details.

The method comprises the following steps: the scene is the calling of an asynchronous method, the callback is the reference of a subclass for realizing the interface obtained and called by using an interface handle, and the callback is triggered and executed at a certain opportunity.

The reflection mechanism is as follows: it means that in the running state, for any class, all the properties and methods of the class can be known, and for any object, any method and property thereof can be called.

Dynamic proxy: a technique for creating a proxy object for a target object and functionally enhancing methods in the target object during program runtime. In the process of generating the proxy object, the target object is not changed, and the method in the proxy object is an enhancement method of the target object method. It can be understood that during run-time, dynamic interception of methods in objects, functional operations are performed before and after the intercepted methods.

Fig. 1 is a flowchart illustrating a remote interface debugging method according to an exemplary embodiment of the present disclosure. The remote interface debugging method is applied to a first terminal device, and referring to fig. 1, the remote interface debugging method comprises the following steps:

in step 101, a remote interface call request is generated.

The remote interface call request carries call parameters, and the call parameters may include class information, method information, parameter information, and the like of the called remote interface. In this disclosure, the called remote interface refers to the SDK interface of the second terminal device.

In some embodiments, the first terminal device may be a game engine and the second terminal device may be a cell phone of the android system.

In step 102, a call parameter carried by the remote interface call request is subjected to a data processing to obtain interface call protocol data, wherein the data processing is used for converting the call parameter into protocol data supported by an SDK interface of a second terminal device connected with the first terminal device according to a preconfigured first interaction protocol.

It should be noted that the first interaction protocol is used to represent the structure body data agreed by the first terminal device and the second terminal device, and the data processing is used to encapsulate the call parameter into the structure body data agreed by the first terminal device and the second terminal device according to the first interaction protocol.

For example, taking a piece of code as an example, the structure data may be:

{"ClassName:com.demo.TestLoginAgent"，

"MethodName:login"，

"IsOstatic:false"，

"Params:["param"]"，

"CallBack:[{

"CallBack className:com,demo.Login Listener"，

"Call Backld:10"，

"Paramlndex:1"

}]"}

in the above-described structure data, information of the call parameter is recorded in the form of a key value pair. For example, ClassName com, demo, TestLoginAgent is a key-value pair of a class field and a class name.

Illustratively, the interface invocation protocol data may be encapsulated in the Json format.

For example, the first terminal device and the second terminal device may be connected by a long connection or by a short connection. The present embodiment is not limited thereto.

In step 103, the interface calling protocol data is sent to the second terminal device, so that the second terminal device parses the interface calling protocol data, and calls the second target method based on the parsing result of the reflection mechanism.

When the second terminal device analyzes the interface call protocol data, the second terminal device can analyze the interface call protocol data according to the first interaction protocol to obtain a call parameter to call the second target method.

According to the technical scheme, the calling parameters carried in the interface calling request are subjected to data processing to obtain interface calling protocol data, and the interface calling protocol data are protocol data supported by an SDK interface of second terminal equipment connected with the first terminal equipment according to a pre-configured first interaction protocol, so that development environment information of the first terminal equipment does not need to be packaged into a specific file and is installed on the second terminal equipment to be tested, the SDK interface of the second terminal equipment can directly identify and analyze the interface calling protocol data, remote calling of the first terminal equipment to the SDK interface of the second terminal equipment is achieved, occupation of a memory of the terminal equipment is reduced, and terminal testing efficiency is improved; and the second terminal equipment calls the second target method based on the reflection mechanism so as to dynamically acquire the second target method in the running state.

The following takes as an example that the first terminal device may be a game engine, and the second terminal device may be a mobile phone of an android system, and a process of the second terminal device invoking the second target method in this disclosure is further explained with reference to fig. 2. Referring to fig. 2, a game engine generates an interface calling protocol (i.e., interface protocol calling data), the SDK side of the mobile phone parses the protocol data (i.e., parses the interface protocol calling data) to obtain class, method, and parameter information (i.e., class field, calling method field, and basic type parameter field), dynamically obtains a class instance (i.e., instance object), obtains parameters (i.e., parameters corresponding to the basic type parameter field), combines the parameters to obtain a parameter list, calibrates the parameters in the parameter list, dynamically obtains a method (i.e., a second target method of the instance object), and further dynamically executes a second target method. Among them, the process shown in fig. 2 is explained in detail with reference to the following examples.

In a possible mode, the interface calling protocol data comprises a class field, a calling method field and a basic type parameter field, and the second terminal device calls the second target method according to the analysis result based on a reflection mechanism through the following modes: analyzing interface calling protocol data according to a first interactive protocol to obtain a class field, a calling method field and a basic type parameter field; acquiring an instance object based on a reflection mechanism according to the class name corresponding to the class field; calibrating the type of the parameter corresponding to the basic type parameter field; acquiring a second target method corresponding to the instance object based on a reflection mechanism according to the calling method field; and calling a second target method based on the reflection mechanism according to the calibrated parameter.

It should be noted that, based on the reflection mechanism, it may be understood that the instance object and the second target method corresponding to the instance object may be dynamically acquired in the operating state of the second terminal device, and the second target method may be dynamically executed.

It should be noted that, since the first interaction protocol is a structure data form agreed by the first terminal device and the second terminal device, the second terminal device may analyze the interface call protocol data according to the first interaction protocol to obtain the class field, the call method field, and the basic type parameter field.

Under the condition that the interface calling protocol data comprises a class field, a calling method field and a basic type parameter field, the interface calling protocol data packaged by the Json can be shown in the following table:

first level field	Description of field
		ClassName	SDK class name, including complete path, transmitted by first terminal deviceInto
MethodName	Calling method name
		Params	Parameter list

The class-one field represents the class of the call parameter, the ClassName represents the class field, and the class field is used for marking the subclass interface of the SDK and marking the path of the subclass interface. The method name represents a calling method field, and the Params represents a basic type parameter field, wherein the parameter list is arranged according to the parameter transmission sequence of all parameters related to the calling method.

Illustratively, the parameter types of the parameter include, but are not limited to, Boolean type, Integer type, Double type, Long type, and the like. Because the first terminal device and the second terminal device have different development environments, languages and the like, the requirements of the parameter types of the parameters corresponding to the basic type parameter field are different. For example, the game engine has an Integer type, but the android system corresponds to a Long type, and if the type of the parameter is not calibrated in the android system, the android system cannot correctly recognize the Integer type, resulting in a call error. Therefore, in this application scenario, to execute the method call normally, it is necessary to calibrate the Integer type parameter to the Long type parameter.

Therefore, in order to shield the data type differentiation between different languages, in the above manner, the second terminal device may calibrate the parameter type of the parameter corresponding to the parameter field of the basic type obtained through analysis, so as to avoid a situation that the second terminal device makes a call error when calling the second target method.

In a possible manner, the step of calibrating the type of the parameter corresponding to the basic type parameter field in the foregoing may include: generating a parameter array according to the parameters corresponding to the basic type parameter field; determining a calling function declared by the method calling field according to the calling method field; and aiming at each parameter in the parameter array, calibrating the type of the parameter according to the type of the parameter and the type of the function parameter which is positioned at the same position as the parameter in the calling function.

For example, the number of parameters corresponding to the basic type parameter field may include a plurality of parameters, and the plurality of parameters may be presented in a list form. The elements of the parameter array are the parameters arranged in the order of the parameters in the list.

It should be noted that the calling function declared by the method calling field and the second target method corresponding to the method calling field refer to the same piece of program code. The calling function is a function which can be normally called by the second terminal equipment side, and the type of the parameter transmitted in the calling function is the type of the parameter which can be correctly identified by the second terminal equipment.

By the method, the type of each parameter in the parameter array is calibrated according to the type of the function parameter of the function which can be normally called by the second terminal equipment side and corresponds to the method calling field, and the method calling error caused by the difference of the data types of the second terminal equipment is avoided.

In a possible manner, for each parameter in the parameter array, the calibrating the type of the parameter according to the type of the parameter and the type of the function parameter at the same position as the parameter in the calling function may include: under the condition that the number of the calling functions is multiple, according to the number of the parameters in the parameter array, determining the calling functions with the same number of the function parameters as the number of the parameters from the multiple calling functions to obtain a target calling function; and aiming at each parameter in the parameter array, calibrating the type of the parameter according to the type of the parameter and the type of a function variable which is positioned at the same position as the parameter in the target calling function.

It should be understood that the number of function parameters of the target call parameter is consistent with the number of parameters included in the parameter array.

It should be noted that the same position may be determined by the order of arranging the parameter arrays and the order of transferring the function parameters to the calling function. For example, the type of the parameter that is located second in the parameter array should be calibrated according to the type of the second function parameter that is passed in to the calling function.

The calling functions with multiple renames corresponding to the method calling fields are considered, so that the parameter quantity conditions of the calling functions are inconsistent according to the specific code conditions of each calling function under the condition that the calling functions comprise multiple calling functions, the target calling functions corresponding to the method calling fields are determined according to the function parameter quantities of the calling functions, and the accuracy of parameter type correction is further ensured.

In a possible way, the mobile phone with the game engine and the android system is considered to have parameter types which can be supported simultaneously, such as Boolean type. For the parameter types that can be simultaneously supported, the terminal device does not need to calibrate such parameters, and therefore, the step of calibrating the parameters corresponding to the parameter fields of the basic type may also include: the method comprises the steps of obtaining a type mapping table, wherein the type mapping table comprises a plurality of first-type parameter types and second-type parameter types corresponding to the first-type parameter types, calibrating the types of the parameters belonging to the first-type parameter types in the parameters corresponding to the basic-type parameter fields, and converting the parameter types of the parameters belonging to the first-type parameter types in the parameters corresponding to the basic-type parameter fields into the second-type parameter types corresponding to the first-type parameter types, so that the calibration of the types of the parameters is realized.

It should be noted that one type of parameter type is a parameter type that cannot be simultaneously supported by the first terminal device and the second terminal device, that is, a type that needs calibration.

By calibrating the functions belonging to one type of parameter types, the time occupied by parameter calibration can be effectively reduced, and the efficiency of the function test of the terminal equipment is further improved.

In a possible manner, the interface call protocol data further comprises a callback type parameter field, the method further comprising: receiving interface callback protocol data returned by the second terminal device, wherein the interface callback protocol data is generated based on a calling result of the second target method; and analyzing the interface callback protocol data line, and calling the first target method based on a reflection mechanism according to an analysis result.

Preferably, when the first terminal device performs a function test on the second terminal device, under some remote invocation conditions, the first terminal device needs to respond to some specific invocation results of the second terminal device, that is, a callback is performed. For example, in a scenario of testing a login function of a second terminal device, a first terminal device calls an interface of the second terminal device to implement remote login, and in a case that the login of the second terminal device fails, the first terminal device needs to analyze a failure reason in the case that the login fails, and since the first terminal device and the second terminal device are remotely called across devices, there is no same operation time state, and a handle of an execution state cannot be held, it is necessary for the second terminal device to feed back a state of failure in executing a login method and information of the failure reason when the execution of the login method fails.

An example of the implementation process of the SDK of the mobile phone in the present disclosure when the interface invocation protocol data further includes a callback type parameter field is further explained with reference to fig. 3. Referring to fig. 3, the mobile phone SDK side obtains a callback instance class and a callback instance object corresponding to the callback instance class through an analysis interface calling protocol data, where the callback instance class and the callback instance object refer to calling objects that need to send callback results to the game engine side, the dynamic proxy instance object monitors the callback method (i.e., the second target method) calling results, packages the callback protocol according to the callback results to obtain received callback protocol data, and sends the received callback protocol data to the game engine side, and the game engine side analyzes data according to the callback protocol data and executes calling of a corresponding method (the first target method). Fig. 3 is explained in detail with reference to the following embodiments and the interaction process of the first terminal device and the second terminal device. Fig. 4 is a schematic diagram of an interaction process between a first terminal device and a second terminal device. As shown in fig. 4, after the second terminal device executes the call of the second target method, the second terminal device first generates interface callback protocol data according to a call result of calling the second target method and sends the interface callback protocol data to the first terminal device, and then the first terminal device parses the interface callback protocol data and calls the first target method according to a parsing result based on a reflection mechanism.

Illustratively, the second terminal device may monitor the instance object by: and dynamically creating a proxy object of the instance object, wherein the proxy object is used for monitoring the calling result of the second target method of the instance object.

For example, in a scenario where the second target method is a login method, when it is monitored that the login method fails to be executed, a callback method name and a callback parameter are determined according to call result information of the second terminal device calling the login method, for example, a method corresponding to the callback method name may be a method for being executed when the login of the second terminal device fails, for example, in a code in the second target method, method a (i.e., callback method name) is called when the execution fails, and a login interface for successful login is returned when the execution succeeds. The callback parameter is a parameter that needs to be used by the method corresponding to the callback method name.

Illustratively, the interface callback protocol data is obtained by encapsulating, by the second terminal device, the callback method name, the callback parameter, and the callback instance object identifier in the callback type parameter field according to the preconfigured second interaction protocol. Similar to the first interactive protocol, the second interactive protocol is also structural body data representing that the first terminal device and the second terminal device agree.

The interface callback protocol data encapsulated by Json can be shown in the following table:

first level field	Description of field
		CallBackID	First terminalIdentification of device CallBack instance object
MethodName	Method name of interface callback result
		Params	Parameter of callback method

The first terminal device caches a CallBack instance in advance, can obtain a CallBack instance object through the identification of the CallBack instance object, and executes calling on the method name of the interface CallBack result corresponding to the CallBack instance object. It should be understood that the identification of the CallBack instance object of the first terminal device is carried in the interface call protocol data.

And the method name of the interface callback result is a callback method name, and is used for indicating the method which the first terminal device should execute, namely the first target method.

The parameters of the callback method are the parameters required to be transmitted by the method corresponding to the name of the callback method.

In a possible manner, the aforementioned step of parsing the interface callback protocol data line and invoking the first target method according to the parsing result based on the reflection mechanism may include: analyzing interface callback protocol data according to a second interaction protocol to obtain a callback instance object identifier, a callback method name and a callback parameter; obtaining a cached callback instance object based on the reflection mechanism according to the callback instance object identifier; acquiring a first target method corresponding to a callback instance object based on a reflection mechanism according to the callback method name; and calling the first target method based on the reflection mechanism according to the callback parameter.

It should be noted that, similar to the understanding of the second terminal device on the reflection mechanism, the second terminal device may also implement, based on the reflection mechanism, dynamically obtaining the callback instance object and the first target method corresponding to the callback instance object in the running state, and may dynamically invoke the first target method.

The CallBack instance object is cached in advance, and the CallBack instance does not need to be created after the interface calling protocol data is received, so that the execution efficiency of the whole closed loop test is improved.

In a possible manner, in a case that the interface call protocol data further includes a callback type parameter field, the step of generating the parameter array according to the parameter corresponding to the basic type parameter field may include: and generating a parameter array according to the parameters corresponding to the basic type parameter field and the callback parameters under the callback type parameter field, wherein the elements in the parameter array are arranged according to the arrangement sequence of the transmission parameters of the second target method.

Exemplarily, in a case that the interface call protocol data further includes a callback type parameter field, the interface call protocol data encapsulated by Json is as shown in the following table:

it should be noted that, the CallBackClassName corresponds to a class name of an interface called by the first terminal device, and the path corresponds to an interface path of the interface. The ParamsIndex characterizes the arrangement order of the incoming parameters needed by the callback function in the second target method.

It should be noted that the callback function is a function passed as a parameter. Therefore, when the parameters are calibrated, the types of the callback functions should be calibrated, so that the method calling errors caused by the difference of the data types by the terminal equipment are avoided.

Based on the same inventive concept, an embodiment of the present disclosure provides a remote interface debugging apparatus, as shown in fig. 5, the remote interface debugging apparatus 500 includes:

a generating module 501, configured to generate a remote interface call request;

a processing module 502, configured to perform a data processing on a call parameter carried in the remote interface call request to obtain interface call protocol data, where the data processing is configured to convert the call parameter into protocol data supported by an SDK interface of a second terminal device connected to the first terminal device according to a preconfigured first interaction protocol;

a sending module 503, configured to send the interface calling protocol data to the second terminal device, so that the second terminal device analyzes the interface calling protocol data, and calls a second target method according to an analysis result based on a reflection mechanism.

Optionally, the interface call protocol data includes a class field, a call method field, and a basic type parameter field, and the second terminal device calls a second target method according to the analysis result based on a reflection mechanism by:

analyzing the interface calling protocol data according to the first interactive protocol to obtain the class field, the calling method field and the basic type parameter field;

acquiring an instance object based on the reflection mechanism according to the class name corresponding to the class field;

calibrating the type of the parameter corresponding to the basic type parameter field; and the number of the first and second electrodes,

acquiring a second target method corresponding to the instance object based on the reflection mechanism according to the calling method field;

and calling the second target method based on the reflection mechanism according to the calibrated parameter.

Optionally, the type of the parameter corresponding to the basic type parameter field is calibrated by:

generating a parameter array according to the parameters corresponding to the basic type parameter field;

determining a calling function declared by the method calling field according to the calling method field;

and aiming at each parameter in the parameter array, calibrating the type of the parameter according to the type of the parameter and the type of the function parameter which is positioned at the same position as the parameter in the calling function.

Optionally, the parameter corresponding to the basic type parameter field is calibrated by the following method, including:

under the condition that the number of the calling functions is multiple, according to the number of the parameters in the parameter array, determining the calling functions with the same number of function parameters as the number of the parameters from the multiple calling functions to obtain target calling functions;

and aiming at each parameter in the parameter array, calibrating the type of the parameter according to the type of the parameter and the type of a function variable which is positioned at the same position as the parameter in the target calling function.

Optionally, the interface call protocol data further includes a callback type parameter field, and the apparatus 500 further includes:

the receiving module is used for receiving interface callback protocol data returned by the second terminal device, wherein the interface callback protocol data is generated based on a calling result of the second target method;

and the calling module is used for analyzing the interface callback protocol data line and calling the first target method based on the reflection mechanism according to the analysis result.

Optionally, the second terminal device generates the interface callback protocol data based on the call result of the second target method by:

creating a proxy object of the instance object, wherein the proxy object is used for monitoring a calling result of a second target method of the instance object;

determining a callback method name and a callback parameter according to the calling result of the second target;

and according to a second pre-configured interaction protocol, converting the callback method name, the callback parameter and the callback instance object identifier under the callback type parameter field into interface callback protocol data supported by the first terminal equipment.

Optionally, the invoking module includes:

the analysis submodule analyzes the interface callback protocol data according to a second interactive protocol to obtain the callback instance object identifier, the callback method name and the callback parameter;

the obtaining submodule is used for obtaining a cached callback instance object based on the reflection mechanism according to the callback instance object identifier;

acquiring a first target method corresponding to the callback instance object based on the reflection mechanism according to the callback method name;

and the calling submodule is used for calling the first target method based on the reflection mechanism according to the callback parameter.

Optionally, the parameter array is generated by:

and generating a parameter array according to the parameters corresponding to the basic type parameter field and the callback parameters under the callback type parameter field, wherein the elements in the parameter array are arranged according to the arrangement sequence of the transmission parameters of the second target method.

Based on the same inventive concept, the disclosed embodiments disclose a computer-readable medium, on which a computer program is stored, characterized in that the program, when executed by a processing device, implements the steps of the method embodiments.

Based on the same inventive concept, the embodiment of the present disclosure discloses a remote interface debugging system, which includes:

Based on the same inventive concept, the disclosed embodiment discloses an electronic device, comprising:

a storage device having a computer program stored thereon;

processing means for executing the computer program in the storage means to implement the steps in the method embodiments.

Referring now to FIG. 6, a block diagram of an electronic device 600 suitable for use in implementing embodiments of the present disclosure is shown. The terminal device in the embodiments of the present disclosure may include, but is not limited to, a mobile terminal such as a mobile phone, a notebook computer, a digital broadcast receiver, a PDA (personal digital assistant), a PAD (tablet computer), a PMP (portable multimedia player), a vehicle terminal (e.g., a car navigation terminal), and the like, and a stationary terminal such as a digital TV, a desktop computer, and the like. The electronic device shown in fig. 6 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present disclosure.

As shown in fig. 6, electronic device 600 may include a processing means (e.g., central processing unit, graphics processor, etc.) 601 that may perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)602 or a program loaded from a storage means 608 into a Random Access Memory (RAM) 603. In the RAM 603, various programs and data necessary for the operation of the electronic apparatus 600 are also stored. The processing device 601, the ROM 602, and the RAM 603 are connected to each other via a bus 604. An input/output (I/O) interface 605 is also connected to bus 604.

Generally, the following devices may be connected to the I/O interface 605: input devices 606 including, for example, a touch screen, touch pad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; output devices 607 including, for example, a Liquid Crystal Display (LCD), a speaker, a vibrator, and the like; storage 608 including, for example, tape, hard disk, etc.; and a communication device 609. The communication means 609 may allow the electronic device 600 to communicate with other devices wirelessly or by wire to exchange data. While fig. 6 illustrates an electronic device 600 having various means, it is to be understood that not all illustrated means are required to be implemented or provided. More or fewer devices may alternatively be implemented or provided.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program carried on a non-transitory computer readable medium, the computer program containing program code for performing the method illustrated by the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network via the communication means 609, or may be installed from the storage means 608, or may be installed from the ROM 602. The computer program, when executed by the processing device 601, performs the above-described functions defined in the methods of the embodiments of the present disclosure.

It should be noted that the computer readable medium in the present disclosure can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present disclosure, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In contrast, in the present disclosure, a computer readable signal medium may comprise a propagated data signal with computer readable program code embodied therein, either in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, optical cables, RF (radio frequency), etc., or any suitable combination of the foregoing.

In some implementations, the electronic devices may communicate using any currently known or future developed network Protocol, such as HTTP (HyperText Transfer Protocol), and may be interconnected with any form or medium of digital data communication (e.g., a communications network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), the Internet (e.g., the Internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed network.

The computer readable medium may be embodied in the electronic device; or may exist separately without being assembled into the electronic device.

The computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: generating a remote interface calling request; performing data processing on a calling parameter carried by the remote interface calling request to obtain interface calling protocol data, wherein the data processing is used for converting the calling parameter into protocol data supported by an SDK interface of second terminal equipment connected with the first terminal equipment according to a pre-configured first interaction protocol; and sending the interface calling protocol data to the second terminal equipment so that the second terminal equipment analyzes the interface calling protocol data, and calling a second target method according to an analysis result based on a reflection mechanism.

Alternatively, the computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: and receiving interface calling protocol data sent by the first terminal equipment, analyzing the interface calling protocol data, and calling a second target method according to an analysis result based on a reflection mechanism.

Computer program code for carrying out operations for the present disclosure may be written in any combination of one or more programming languages, including but not limited to an object oriented programming language such as Java, Smalltalk, C + +, and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in 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 which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The modules described in the embodiments of the present disclosure may be implemented by software or hardware. Where the name of a module does not in some cases constitute a limitation on the module itself, for example, a generating module may also be described as a "module that generates a remote interface call request".

The functions described herein above may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), systems on a chip (SOCs), Complex Programmable Logic Devices (CPLDs), and the like.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

According to one or more embodiments of the present disclosure, example 1 provides a remote interface debugging method applied to a first terminal device, including:

generating a remote interface calling request;

Example 2 provides the method of example 1, wherein the interface call protocol data includes a class field, a call method field, and a basic type parameter field, and the second terminal device calls a second target method according to the parsing result based on a reflection mechanism by:

acquiring an instance object based on a reflection mechanism according to the class name corresponding to the class field;

In accordance with one or more embodiments of the present disclosure, example 3 provides a method of example 2,

the calibrating the type of the parameter corresponding to the basic type parameter field comprises:

Example 4 provides a method of example 3, the calibrating, for each of the parameters in the parameter array, a type of the parameter according to the type of the parameter and a type of a function parameter co-located with the parameter in the calling function, including:

Example 5 provides the method of example 2, the interface call protocol data further including a callback type parameter field, the method further comprising:

receiving interface callback protocol data returned by the second terminal device, wherein the interface callback protocol data is generated based on a calling result of the second target method;

and analyzing the interface callback protocol data line, and calling a first target method based on the reflection mechanism according to an analysis result.

Example 6 provides the method of example 5, wherein the second terminal device generates the interface callback protocol data based on a result of the invocation of the second target method by: creating a proxy object of the instance object, wherein the proxy object is used for monitoring a calling result of a second target method of the instance object;

determining a callback method name and a callback parameter according to the calling result of the second target method;

Example 7 provides the method of example 5, wherein parsing the interface callback protocol data line and invoking a first target method according to a result of the parsing based on the reflection mechanism, includes:

analyzing the interface callback protocol data according to a second interactive protocol to obtain the callback instance object identifier, the callback method name and the callback parameter;

obtaining a cached callback instance object based on the reflection mechanism according to the callback instance object identifier;

and calling the first target method based on the reflection mechanism according to the callback parameter.

In accordance with one or more embodiments of the present disclosure, example 8 provides a method of example 5,

generating a parameter array according to the parameters corresponding to the basic type parameter field, wherein the parameter array comprises:

Example 9 provides, in accordance with one or more embodiments of the present disclosure, a remote interface debugging apparatus comprising:

Example 10 provides a computer-readable medium having stored thereon a computer program that, when executed by a processing device, performs the steps of the method of any of examples 1-8, in accordance with one or more embodiments of the present disclosure.

Example 11 provides, in accordance with one or more embodiments of the present disclosure, an electronic device, comprising:

a storage device having a computer program stored thereon;

processing means for executing the computer program in the storage means to carry out the steps of the method of any of examples 1-8.

Example 12 provides, in accordance with one or more embodiments of the present disclosure, a remote interface debugging system, comprising:

The foregoing description is only exemplary of the preferred embodiments of the disclosure and is illustrative of the principles of the technology employed. It will be appreciated by those skilled in the art that the scope of the disclosure herein is not limited to the particular combination of features described above, but also encompasses other embodiments in which any combination of the features described above or their equivalents does not depart from the spirit of the disclosure. For example, the above features and (but not limited to) the features disclosed in this disclosure having similar functions are replaced with each other to form the technical solution.

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

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims. With regard to the apparatus in the above-described embodiment, the specific manner in which each module performs the operation has been described in detail in the embodiment related to the method, and will not be elaborated here.

Claims

1. A remote interface debugging method is applied to a first terminal device and comprises the following steps:

generating a remote interface calling request;

2. The method of claim 1, wherein the interface call protocol data includes a class field, a call method field, and a basic type parameter field, and wherein the second terminal device calls the second target method based on the parsing result by:

3. The method of claim 2, wherein calibrating the type of the parameter corresponding to the base type parameter field comprises:

determining a calling function declared by the calling method field according to the calling method field;

4. The method of claim 3, wherein for each parameter in the parameter array, calibrating the type of the parameter according to the type of the parameter and the type of the function parameter at the same position in the calling function as the parameter comprises:

5. The method of claim 2, wherein the interface invocation protocol data further includes a callback type parameter field, the method further comprising:

6. The method according to claim 5, wherein the second terminal device generates the interface callback protocol data based on the result of the call of the second target method by:

7. The method of claim 5, wherein parsing the interface callback protocol data line and invoking the first target method based on the reflection mechanism according to a result of the parsing comprises:

8. The method of claim 5, wherein generating an array of parameters based on the parameters corresponding to the base type parameter field comprises:

9. A remote interface debugging apparatus, comprising:

10. A computer-readable medium, on which a computer program is stored, characterized in that the program, when being executed by processing means, carries out the steps of the method of any one of claims 1 to 8.

11. An electronic device, comprising:

a storage device having a computer program stored thereon;

processing means for executing the computer program in the storage means to carry out the steps of the method according to any one of claims 1 to 8.

12. A remote interface debugging system, comprising: