Application debugging method and device

Abstract

The invention relates to the technical field of electronic equipment, and particularly provides an application debugging method and device. The application debugging method comprises the steps of analyzing a compiling code of a target application to obtain an element code of each page element, configuring a preset operation event for each page element according to the element code of each page element, generating a target installation file according to the element code of each page element after the preset operation event is configured, and debugging the target installation file according to the target installation file. And sending the target installation file to the operation end. In the embodiment of the invention, the interaction between the developer and the running end can be provided through the preset operation event, so that more debugging information is displayed, the developer does not need to search the page element debugging information from the original compiled code, the application debugging process is greatly facilitated, and the development efficiency is improved.

Description

Technical Field

[0001] The present disclosure relates to the technical field of electronic equipment, and in particular to an application debugging method and device. Background Art

[0002] During the application (App, Application) development process, developers find that the application style or function does not meet expectations. They need to adjust the code on the compilation side and send it to the runtime side. After running on the runtime side, they need to check the effect of the modification and repeat this process to complete application debugging.

[0003] In the related art, the running end can present little debugging information after running the code, and cannot interact with the developer for the debugging scenario, resulting in a poor application debugging experience and low development efficiency. Summary of the invention

[0004] In order to improve application debugging efficiency and shorten the application development cycle, the embodiments of the present disclosure provide an application debugging method, device, electronic device and storage medium.

[0005] In a first aspect, an embodiment of the present disclosure provides an application debugging method, which is applied to a compile end, and the method includes:

[0006] Parsing the compiled code of the target application to obtain the element code of each page element in the page structure of the target application;

[0007] According to the element code of each page element, a preset operation event is configured for each page element, so that when the preset operation event is executed on the page element, pre-configured debugging information corresponding to the page element is displayed;

[0008] Generate a target installation file of the target application according to the element code of each page element after configuring the preset operation event, and send the target installation file to the running end so that the running end installs the target application according to the target installation file.

[0009] In some implementations, configuring a preset operation event for each page element according to the element code of each page element includes:

[0010] Determine the debugging information corresponding to each page element according to the element code of each page element;

[0011] The preset operation event and the debugging information are configured in the element code of each page element.

[0012] In some implementations, generating the target installation file of the target application according to the element code of each page element after configuring the preset operation event includes:

[0013] Packaging is performed according to the element code of each page element after the preset operation event is configured to obtain an installation package of the target application;

[0014] The target installation file is obtained by configuring the installation package with preset identification information; the preset identification information is used to trigger the operation of the running end to call the target system interface.

[0015] In some implementations, the preset operation event includes a long press event, and the debugging information includes size information and / or position information of the page element.

[0016] In a second aspect, an embodiment of the present disclosure provides an application debugging method, which is applied to a running end, and the method includes:

[0017] Receiving a target installation file sent by the compiling end, and installing a target application according to the target installation file, wherein the target installation file is obtained by the compiling end through the method described in any implementation manner of the first aspect;

[0018] In response to receiving a preset operation event for a page element of the target application, debugging information corresponding to the page element is displayed.

[0019] In some implementations, the application debugging method described in the present disclosure further includes:

[0020] In response to parsing the preset identification information in the target installation file of the target application, calling the target system interface corresponding to the preset identification information to obtain target configuration information; the target configuration information includes memory information and / or display frame rate information of the running terminal;

[0021] Display the target configuration information.

[0022] In some implementations, the running end includes a mobile terminal and a wearable device, and the mobile terminal establishes a wireless communication connection with the wearable device; the receiving the target installation file sent by the compiling end and installing the target application according to the target installation file includes:

[0023] The mobile terminal receives the target installation file sent by the compiling end, and sends the target installation file to the wearable device;

[0024] The wearable device installs the target application according to the target installation file.

[0025] In a third aspect, an embodiment of the present disclosure provides an application debugging device, which is applied to a compiling end, and the device includes:

[0026] A code parsing module is configured to parse the compiled code of the target application to obtain the element code of each page element in the page structure of the target application;

[0027] An event configuration module is configured to configure a preset operation event for each page element according to an element code of each page element, so that when the preset operation event is executed on the page element, pre-configured debugging information corresponding to the page element is displayed;

[0028] The file sending module is configured to generate a target installation file of the target application according to the element code of each page element after configuring the preset operation event, and send the target installation file to the running end so that the running end installs the target application according to the target installation file.

[0029] In a fourth aspect, an embodiment of the present disclosure provides an application debugging device, which is applied to a running end, and the device includes:

[0030] A file receiving module, configured to receive a target installation file sent by a compiling end, and install a target application according to the target installation file, wherein the target installation file is obtained by the compiling end through the method described in any implementation manner of the first aspect;

[0031] The information display module is configured to display debugging information corresponding to the page element in response to receiving a preset operation event for the page element of the target application.

[0032] In a fifth aspect, an embodiment of the present disclosure provides an electronic device, including:

[0033] Processor; and

[0034] A memory storing computer instructions, wherein the computer instructions are used to enable the processor to execute the method according to any implementation of the first aspect or the second aspect.

[0035] In a sixth aspect, an embodiment of the present disclosure provides a storage medium storing computer instructions, wherein the computer instructions are used to enable a computer to execute the method described in any embodiment of the first aspect or the second aspect.

[0036] The application debugging method of the disclosed embodiment includes parsing the compiled code of the target application to obtain the element code of each page element, configuring a preset operation event for each page element according to the element code of each page element, generating a target installation file according to the element code of each page element after configuring the preset operation event, and sending the target installation file to the running end. In the disclosed embodiment, the preset operation event can provide interaction between the developer and the running end, thereby displaying more debugging information. The developer does not need to search for page element debugging information from the original compiled code, which greatly facilitates the application debugging process and improves development efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] In order to more clearly illustrate the specific embodiments of the present disclosure or the technical solutions in the prior art, the drawings required for use in the specific embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present disclosure. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0038] Figure 1 is a flowchart of an application debugging method in some implementations of the present disclosure.

[0039] Figure 2 It is a scene graph of an application debugging method according to some implementation modes of the present disclosure.

[0040] Figure 3 It is a scene graph of an application debugging method according to some implementation modes of the present disclosure.

[0041] Figure 4 is a flowchart of an application debugging method in some implementations of the present disclosure.

[0042] Figure 5 It is a scene graph of an application debugging method according to some implementation modes of the present disclosure.

[0043] Figure 6 It is a scene graph of an application debugging method according to some implementation modes of the present disclosure.

[0044] Figure 7 is a flowchart of an application debugging method in some implementations of the present disclosure.

[0045] Figure 8 It is a scene graph of an application debugging method according to some implementation modes of the present disclosure.

[0046] Fig. 9 is a flowchart of an application debugging method in some implementations of the present disclosure.

[0047] Fig.10It is a scene graph of an application debugging method according to some implementation modes of the present disclosure.

[0048] Fig.11 is a flowchart of an application debugging method in some implementations of the present disclosure.

[0049] Fig.12 It is a scene graph of an application debugging method according to some implementation modes of the present disclosure.

[0050] Fig.13 is a flowchart of an application debugging method in some implementations of the present disclosure.

[0051] Fig.14 It is a structural block diagram of an application debugging device in some implementation modes of the present disclosure.

[0052] Fig.15 It is a structural block diagram of an application debugging device in some implementation modes of the present disclosure.

[0053] Fig.16 It is a structural block diagram of an electronic device according to some implementations of the present disclosure. DETAILED DESCRIPTION

[0054] The technical solution of the present disclosure will be described clearly and completely below in conjunction with the accompanying drawings. Obviously, the described implementation is a part of the implementation of the present disclosure, rather than all the implementations. Based on the implementation in the present disclosure, all other implementations obtained by ordinary technicians in the field without creative work are within the scope of protection of the present disclosure. In addition, the technical features involved in the different implementations of the present disclosure described below can be combined with each other as long as they do not conflict with each other.

[0055] Developers need to continuously debug their applications during the application (App, Application) development process. Application debugging means that when developers find that the application style or function does not meet expectations, they need to adjust the code on the compilation side and send it to the running side. After running on the running side, check the effect of the modification, and repeat this process until it meets expectations. The application debugging process is completed.

[0056] The compilation end refers to the device used to implement functions such as application code compilation, modification, and packaging, generally a PC (Personal Computer). The running end refers to the device used to run the application, generally a mobile terminal, wearable device, etc.

[0057] Figure 1 The flowchart of application debugging in the related technology is shown below. Figure 1 A brief description of the application debugging process.

[0058] like Figure 1As shown, the developer first writes the application code on the compilation side, and then packages it into an RPK file after the code is written. The RPK file is a system file with the suffix .RPK and is a type of application installation package. The compilation side sends the packaged RPK file to the running side, and the running side can run the application according to the received RPK file. The developer can check whether the application meets expectations based on the application style and functions displayed on the real machine on the running side. If it does not meet expectations, it is necessary to modify the code on the compilation side again, and then package the modified code into an RPK file and send it to the running side again for running. Repeat this process until the application meets expectations. This process is the application debugging process.

[0059] However, in practice, it is found that during the application debugging process of related technologies, after the running end runs the RPK file, it generally only renders and displays the application elements, and can present little debugging-related information, and cannot interact with developers for debugging scenarios, especially for the lack of debugging information related to the UI (User Interface), resulting in low efficiency in application UI development.

[0060] For example, in one example, the developer hopes to adjust the size of each component element of the application UI interface. After running the RPK file on the runtime side, each component element can only be displayed on the display interface, and the developer cannot know the specific width and height of each component element. If the developer thinks that the size of a component element is too large and wants to reduce the size of the component element, he can only find the specific size of the component element from the original code and then modify it. The entire application debugging experience is poor, affecting the efficiency of application development.

[0061] Based on the defects of the above-mentioned related technologies, the embodiments of the present disclosure provide an application debugging method, device, electronic device and storage medium, which aim to improve the interactive experience between the operating end and the developer during the application debugging process, enrich the debugging information displayed by the operating end, improve the application debugging efficiency, and shorten the application development cycle.

[0062] Figure 2 and Figure 3 Two application debugging scenarios in some embodiments of the present disclosure are shown respectively. Figure 2 and Figure 3 The application scenarios of the disclosed method are described.

[0063] like Figure 2 As shown, in some implementations, the compiling end may be a PC, and the running end may be a mobile terminal. The PC and the mobile terminal may establish a wired communication connection via a data line, or may establish a wireless communication connection via wireless communication.

[0064] After the developer writes and modifies the application code on the compiler side, the compiler side packages the application code into an RPK file and sends it to the runtime side via wired or wireless means. The runtime side runs the RPK file, and the developer can view the actual running results on the real machine on the runtime side. If the running results do not meet expectations, the problematic code can be modified on the compiler side, and then the modified application code can be repackaged into an RPK file and sent to the runtime side for re-running.

[0065] like Figure 3 As shown, in some embodiments, the compiling end may also be a PC, and the running end may include a mobile terminal and a wearable device. It is understood that the application described in the present disclosure may be a web application (Web App) running on a web page, a native application (Native-App) running on a mobile terminal, or a quick application running on a wearable device.

[0066] Quick apps are a new type of application based on mobile hardware platforms. They are a type of application between web apps and native apps. Quick apps have the advantages of good user interaction of native apps and cross-platform development of web apps. They are click-to-use and can bring a smooth application experience. Therefore, they are very suitable for running on small memory devices (such as wearable devices).

[0067] exist Figure 3 In the example scenario, after the developer writes and packages the RPK file on the compiler side, the RPK file cannot be sent directly to the wearable device, and needs to be forwarded through the relevant application of the mobile terminal. For example, a common smart watch can be used as an example of a wearable device. The smart watch can complete the Bluetooth binding with the mobile phone through the "Sports App" on the mobile phone. Therefore, when debugging the quick application on the watch, the developer can write and package the RPK file on the compiler side, and then send the RPK file to the mobile terminal wirelessly or wired. Then the mobile terminal forwards the RPK file to the wearable device through the wireless connection with the wearable device. After receiving the RPK file forwarded by the mobile terminal, the wearable device can run, realizing the real machine debugging for the wearable device.

[0068] Based on the aforementioned application scenario, an embodiment of the present disclosure provides an application debugging method, which includes method steps executed by a compile end and method steps executed by a run end, which will be described separately below.

[0069] Before debugging an application, you need to configure the connection and development environment between the compiler and runtime. Figure 3 Taking the scenario shown in the figure as an example, the configuration process of quick application debugging on a wearable device is described.

[0070] First, developers need to prepare a PC as the compilation end, a mobile terminal and wearable devices as the running end.

[0071] Secondly, it is necessary to configure the development environment for the quick application on the PC side according to the official application development documents. For example, in one example, the development environment can be configured using an IDE (Integrated Development Environment) tool on the PC side, which can be understood by those skilled in the art and will not be described in detail in this disclosure.

[0072] Then, it is necessary to establish a communication connection between the PC and the mobile terminal. In some embodiments, the PC and the mobile terminal can establish a wired connection via a data cable. In other embodiments, considering that the wired connection method is more cumbersome, a wireless connection between the PC and the mobile terminal can be established through ADB (Android Debug Bridge) technology. For the process and principle of establishing an ADB wireless connection, those skilled in the art can understand and fully implement it with reference to the relevant technology, and this disclosure will not repeat it.

[0073] After that, an application program for establishing a connection with the wearable device needs to be installed on the mobile terminal, which is generally a sports app. Through this application program, the pairing and binding connection between the mobile terminal and the wearable device can be completed, and the connection method is generally a Bluetooth wireless connection. For the pairing and connection process between the mobile terminal and the wearable device, those skilled in the art can understand and fully implement it by referring to the relevant technology, and this disclosure will not repeat it.

[0074] After completing the above preparations, the application debugging of the running end can be implemented based on the application debugging method below in the present disclosure. Figure 4 Provide explanation.

[0075] like Figure 4 As shown, in some implementations, the application debugging method of the example of the present disclosure may be applied to a compile end, and the compile end device performs processing, which includes:

[0076] S410: Parse the compiled code of the target application to obtain the element code of each page element in the page structure of the target application.

[0077] In the embodiments of the present disclosure, the target application refers to the application that needs to be debugged on the running end. Depending on the running end, the target application can also be any type of application, and the present disclosure does not limit this. For example, the target application may include a hybrid mobile application (Hybrid App), a web application (Web App), a native application (Native-App), a quick application, etc.

[0078] The compiled code of the target application refers to the relevant code written by the developer to implement the target application. It can be understood that the code of the application mainly includes three files: page structure (UX), page style (CSS) and page logic (JS). Among them, the page structure UX file includes the element code of each page element on each page. A page element refers to a component on a page. A page can be composed of multiple page elements, and each page element corresponds to an element code in the page structure UX.

[0079] For example, in one example, a page of the target application is Figure 5 As shown, in Figure 5 In this example, the target application is a music application, and the page includes a virtual button that implements the "previous song" function. A virtual button “||” for “pause” and a virtual button for “next song” Each virtual button is a page element, and each page element is mapped to an element code in the page structure UX file of the compiled code of the target application.

[0080] Therefore, in the embodiment of the present disclosure, by parsing the compiled code of the target application and parsing the page structure UX file, the element code corresponding to each page element can be obtained.

[0081] S420: According to the element code of each page element, configure a preset operation event for each page element.

[0082] In the disclosed implementation manner, the preset operation event refers to an operation event in which the developer interacts with the running end, which can be any type of operation event such as "long press", "double click", "slide" and so on.

[0083] In the disclosed embodiment, it is necessary to configure a preset operation event for the element code of each page element. The purpose of configuring the preset operation event is that when a preset operation event is executed on a certain page element, the operating end can display the pre-configured debugging information corresponding to the page element.

[0084] Debug information refers to information related to page elements, for example, debug information may include size information, position information, etc. Size information may be represented by the area (width*height) occupied by the page element in the page structure, and position information may be represented by the position coordinates (x, y) of the page element in the page structure.

[0085] It can be understood that for the compilation end, the element code of each page element is obtained by parsing the compiled code of the target application, and then the preset operation events are configured in the element code of each page element, so that after the target application is run on the running end, each page element can interact with the developer through the preset operation events. When the developer executes the preset operation event on a page element, the running end can display the debugging information related to the page element. The developer can intuitively view the debugging information of each page element without having to search from the original compiled code.

[0086] The process of configuring a preset operation event for each page element is described in the following implementation of the present disclosure and will not be described in detail here.

[0087] S430: Generate a target installation file of the target application according to the element code of each page element after configuring the preset operation event, and send the target installation file to the running end.

[0088] It can be understood that, for the compiler, after configuring the preset operation event for the page code of each page element, the code of the target application can be packaged to generate a target installation file. The target installation file is also the aforementioned RPK file, in which each page element has been configured with a preset operation event.

[0089] After the compilation end packages the target installation file, the target installation file can be sent to the running end by wireless or wired means.

[0090] For example Figure 2 In the scenario shown, the compiler can send the target installation file to the mobile terminal through the ADB wireless connection, so that the mobile terminal can run the target installation file to achieve the installation and operation of the target application.

[0091] For example Figure 3 In the scenario shown, the compiler can send the target installation file to the mobile terminal through ADB wireless connection, and then the mobile terminal forwards the target installation file to the wearable device through Bluetooth communication. The wearable device can run the target installation file to achieve the installation and operation of the target application.

[0092] After the target application is run on the running side, since each page element is configured with a preset operation event, the developer can trigger any page element through the preset operation event on the running side to view the debugging information of the page element.

[0093] For ease of understanding, in an example, the preset operation event will be described using "long press" as an example, and the debugging information will be described using "size information" as an example.

[0094] In the traditional application debugging method, after the running end runs the target application, the display interface can be as follows: Figure 5 As shown in the figure. Since the traditional solution does not configure preset operation events for page elements, developers cannot view the size information of a page element by "long pressing".

[0095] For example, during the UI design process, if the developer finds that the size of a page element is too large, he or she needs to find out the specific size of the page element, which is 200*50 pixels, from the original compiled code, and then modify the element code of the page element to change the size to, for example, 150*50 pixels. Then, repeat the above process, repackage and send the RPK file to the running end to view the modified effect.

[0096] In the application debugging method of the embodiment of the present disclosure, after the running end runs the target application, the display interface can be as follows: Figure 5 As shown. Since a preset operation event has been configured for each page element, when the developer wants to view the size information of a page element, he only needs to long press the page element to display the size information of the page element.

[0097] For example, during the UI design process, if the developer finds that the size of a page element is too large, the developer can long-press the page element on the runtime side. In response to the long-press operation, the runtime side can display the size information of the page element, such as Figure 6 In the example, after long pressing a page element, the runtime displays the size information of the page element, "200*50" pixels. It can be seen that developers do not need to find the specific size of the page element from the original compiled code, but can directly view the size information of the page element by long pressing the runtime, which greatly facilitates the application debugging process.

[0098] From the above, it can be seen that in the embodiments of the present disclosure, preset operation events can provide interaction between developers and the running end, thereby displaying more debugging information. Developers do not need to search for page element debugging information from the original compiled code, which greatly facilitates the application debugging process and improves development efficiency.

[0099] like Figure 7 As shown, in some implementations, the application debugging method of the present disclosure example, the process of configuring a preset operation event for each page element includes:

[0100] S421. Determine debugging information corresponding to each page element according to the element code of each page element.

[0101] S422: Configure preset operation events and debugging information in the element code of each page element.

[0102] In some implementations, the IDE tool interface of the compiler end can be as follows: Figure 8 As shown, developers can use Figure 8 The tool interface shown enables writing, modifying and packaging of compiled code for the target application.

[0103] In the embodiment of the present disclosure, the element code of each page element can be obtained by parsing the page structure UX file of the compiled code of the target application. The element code of each page element will record the size information, position information, etc. corresponding to the page element. The debugging information of the page element described in the present disclosure includes the size information and / or position information of the page element.

[0104] Combination Figure 8 As shown, after parsing the element code of each page element and obtaining debugging information based on the element code, the developer can rewrite the element code of each page element through the IDE tool. The purpose of the rewriting is to configure Events in the element code of each page element. The Events are the preset operation events described in the present disclosure, which can be any trigger event type suitable for implementation, such as long press, double click, slide, etc., and the present disclosure does not limit this.

[0105] For example, taking long press as an example of the preset operation event, a Longpress attribute can be added to the Events field of the element code of each page element. The Longpress attribute will be mapped to the debugging information of the page element to obtain specific debugging information, and then the running end can print and display the debugging information on the page.

[0106] From the above, it can be seen that in the embodiment of the present disclosure, by configuring preset operation events for each page element, it is possible to provide interaction between the developer and the running end, thereby displaying more debugging information. The developer does not need to search for page element debugging information from the original compiled code, which greatly facilitates the application debugging process and improves development efficiency.

[0107] In the process of application development, the display frame rate and memory usage of the application are parts that cannot be ignored, especially for the development of quick applications for wearable devices. Since the memory of wearable devices themselves is relatively small, if the quick application occupies a large amount of memory when running, it is easy to cause problems such as lag, frame rate drop, or even freezing. Therefore, it is very important to optimize the display frame rate and memory usage during application debugging. However, in traditional application debugging solutions, the running end does not display the current frame rate and memory usage. Developers can only manually call the running end API (Application Programming Interface) to obtain this information, which further increases the workload during debugging and leads to low debugging efficiency.

[0108] Therefore, in some embodiments of the present disclosure, the compiler can configure preset identification information in the RPK file during the process of packaging and generating the RPK file, so that when the running end runs the RPK file, it automatically calls the underlying API interface according to the preset identification information obtained by parsing to obtain and display information such as frame rate and memory. Fig. 9 Provide explanation.

[0109] like Fig. 9 As shown, in some implementations, the application debugging method of the example of the present disclosure, the process of generating a target installation file of the target application includes:

[0110] S431. Packaging is performed according to the element code of each page element after the preset operation event is configured to obtain an installation package of the target application.

[0111] S432: Configuring preset identification information for the installation package to obtain a target installation file.

[0112] In the implementation manner of the present disclosure, the element code of each page element can be configured with a preset operation event through the aforementioned process. Those skilled in the art may refer to the aforementioned method process, which will not be described in detail.

[0113] Combination Figure 8 As shown, after configuring the preset operation events for the element code of each page element, you can click the "Package" button in the IDE tool interface to automatically package the compiled code and obtain the RPK file, which is also the installation package of the target application described in the present disclosure.

[0114] In the embodiment of the present disclosure, after the installation package is obtained, the installation package is not directly sent to the running end, but preset identification information is configured for the installation package to obtain the target installation file.

[0115] For example Figure 8 In the example, a "debug" identifier can be written in the package name of the installation package, and the "debug" identifier is the preset identifier information described in the present disclosure. The preset identifier information is used to identify the installation package as a debugging installation package, not an actual version installation package. Of course, those skilled in the art will understand that the preset identifier information is not limited to Figure 8 The example "debug" may also be any other identification information, and the present disclosure is not limited to this.

[0116] Still Figure 8For example, after configuring the "debug" identification information for the package name of the installation package RPK file, the target installation file can be obtained. Then the compilation end can send the target installation file to the running end. After receiving the target installation file, the running end can parse the target installation file to obtain the preset identification information (that is, the debug identification) carried in the package name, so that the RPK file can be obtained as a debugging version, and the system's underlying API interface can be automatically called to obtain the current display frame rate and / or memory information and display it.

[0117] In one example, the display interface of the running terminal can be as follows: Fig.10 As shown, in Fig.10 In the example, the current frame rate information "62FPS" and memory information "1.3MB MEM" can be displayed on the upper layer of the page elements.

[0118] From the above, it can be seen that in the embodiment of the present disclosure, by configuring preset identification information in the target installation file, the operating end can automatically call the target system interface according to the preset identification information, so that more information can be displayed on the operating end without the developer having to manually call the required information, thereby improving the application debugging efficiency and shortening the application development cycle.

[0119] In some embodiments, the present disclosure provides an application debugging method, which can be applied to the running end. In the embodiments of the present disclosure, the running end can be as follows Figure 2 The figure only includes mobile terminals, and can also be as shown Figure 3 The mobile terminal and the wearable device are shown, and the mobile terminal and the wearable device establish a wireless communication connection via Bluetooth. Those skilled in the art can understand this, and the present disclosure will not repeat it.

[0120] like Fig.11 As shown, in some implementations, the application debugging method of the example of the present disclosure includes:

[0121] S1110. Receive a target installation file sent by the compiling end, and install a target application according to the target installation file.

[0122] In some embodiments, Figure 2 In the scenario shown, the compiling end is a PC and the running end is a mobile terminal. After the compiling end obtains the target installation file through the aforementioned method process and sends the target installation file to the mobile terminal, the mobile terminal can install the target application according to the received target installation file. After the target application is installed, the target application can be started and run directly, or it can be run in response to the developer's startup operation.

[0123] In other embodiments, Figure 3In the scenario shown, the compiling end is a PC, and the running end includes a mobile terminal and a wearable device. After the compiling end obtains the target installation file through the aforementioned method process and sends the target installation file to the mobile terminal, the display interface of the sports app of the mobile terminal can be as follows Fig.12 As shown in (a).

[0124] Developers can Fig.12 Click "Application Debug" on the interface shown in (a) and the display interface will switch to the following Fig.12 The interface shown in (b) in the figure, and then the developer Fig.12 Enter the package name of the target installation file in the "Enter package name" text box shown in (b) in the figure. The package name of the target installation file is Figure 8 In the example, a package name with preset identification information is configured, and then the "Install" button is clicked, and the mobile terminal can send the target installation file to the wearable device. The wearable device can install the target application according to the received target installation file. After the target application is installed, the target application can be started and run directly, or it can be run in response to the developer's start operation.

[0125] S1120: In response to receiving a preset operation event for a page element of a target application, display debugging information corresponding to the page element.

[0126] In the disclosed embodiment, after running the target application, the running end can display the page of the target application. When the developer performs a preset operation event on a certain page element, the running end can detect the preset operation event for the page element, and then display the debugging information corresponding to the page element on the page of the running end through the debugging information configured by the compiling end.

[0127] For example, the aforementioned Figure 5 In the example scenario, the page displayed on the running end is as follows Figure 5 As shown, the preset operation event is a long press operation. After the wearable device runs the target application, the developer can long press a page element on the page. After the wearable device detects the long press event, it can display the size information of the page element on the page according to the pre-configured size information, for example Figure 6 As shown, the size information is 200*50 pixels.

[0128] Of course, those skilled in the art will understand that the debugging information is not limited to the size information in the above examples, but may also include, for example, the position information of the page elements. The position information may be represented by the coordinates of the page elements, which is understandable to those skilled in the art and will not be elaborated in this disclosure.

[0129] From the above, it can be seen that in the embodiment of the present disclosure, preset operation events can provide interaction between developers and the running end, thereby displaying more debugging information. Developers do not need to search for page element debugging information from the original compiled code, which greatly facilitates the application debugging process and improves development efficiency.

[0130] like Fig.13 As shown, in some implementations, the application debugging method of the example of the present disclosure includes:

[0131] S1310: In response to parsing preset identification information in a target installation file of a target application, calling a target system interface corresponding to the preset identification information to obtain target configuration information.

[0132] S1320. Display target configuration information.

[0133] In the embodiments of the present disclosure, combined with the above Fig. 9 It can be seen from the implementation method that the compiler can configure preset identification information in the installation package when packaging the RPK file, such as the aforementioned Figure 8 In the example, a "debug" identifier may be written into the package name of the installation package, and the "debug" identifier is the preset identifier information described in the present disclosure.

[0134] After receiving the target installation file sent by the compilation end, the running end can read the preset identification information carried in the package name by parsing the target installation file, so that the RPK file can be obtained as a debugging version, and the target system interface corresponding to the preset identification information can be automatically called. The target system interface is the API interface of the running end, and various system bottom configuration information can be obtained by calling the API interface, that is, the target configuration information described in this disclosure.

[0135] For example, in the above example, the target configuration information may include the display frame rate information and memory information of the running end, so that after the running end calls the API interface to obtain the display frame rate information and memory information, it can display the following information on the page: Fig.10 The frame rate information shown is "62FPS" and the memory information is "1.3MB MEM".

[0136] From the above, it can be seen that in the embodiment of the present disclosure, by configuring preset identification information in the target installation file, the operating end can automatically call the target system interface according to the preset identification information, so that more information can be displayed on the operating end without the developer having to manually retrieve the required information, thereby improving application debugging efficiency and shortening the application development cycle.

[0137] In some embodiments, the present disclosure provides an application debugging device, which can be applied to a compiling end, such as Fig.14 As shown, the application debugging device includes:

[0138] The code parsing module 10 is configured to parse the compiled code of the target application to obtain the element code of each page element in the page structure of the target application;

[0139] The event configuration module 20 is configured to configure a preset operation event for each page element according to the element code of each page element, so that when the preset operation event is executed on the page element, the pre-configured debugging information corresponding to the page element is displayed;

[0140] The file sending module 30 is configured to generate a target installation file of the target application according to the element code of each page element after the preset operation event is configured, and send the target installation file to the running end so that the running end installs the target application according to the target installation file.

[0141] In some embodiments, the present disclosure provides an application debugging device, which can be applied to a running end, such as Fig.15 As shown, the application debugging device includes:

[0142] A file receiving module 40 is configured to receive a target installation file sent by the compiling end, and install a target application according to the target installation file, wherein the target installation file is obtained by the compiling end through the method of any implementation mode of the first aspect;

[0143] The information display module 50 is configured to display debugging information corresponding to the page element in response to receiving a preset operation event for the page element of the target application.

[0144] In some embodiments, the present disclosure provides an electronic device, which may be a compiling end or a running end in any of the above embodiments, and the present disclosure does not limit this. In some embodiments, the electronic device includes:

[0145] Processor; and

[0146] The memory stores computer instructions, where the computer instructions are used to enable the processor to execute the method of any of the above embodiments.

[0147] In some embodiments, the present disclosure provides a storage medium storing computer instructions, where the computer instructions are used to enable a computer to execute the method of any of the above embodiments.

[0148] Fig.16 The electronic device structure in some embodiments of the present disclosure is shown in FIG. Fig.16 Electronic devices according to some embodiments of the present disclosure are described.

[0149] Reference Fig.16, the electronic device 1800 may include one or more of the following components: a processing component 1802 , a memory 1804 , a power component 1806 , a multimedia component 1808 , an audio component 1810 , an input / output (I / O) interface 1812 , a sensor component 1816 , and a communication component 1818 .

[0150] The processing component 1802 generally controls the overall operation of the electronic device 1800, such as operations associated with display, phone calls, data communications, camera operations, and recording operations. The processing component 1802 may include one or more processors 1820 to execute instructions. In addition, the processing component 1802 may include one or more modules to facilitate interaction between the processing component 1802 and other components. For example, the processing component 1802 may include a multimedia module to facilitate interaction between the multimedia component 1808 and the processing component 1802. For another example, the processing component 1802 may read executable instructions from a memory to implement electronic device related functions.

[0151] The memory 1804 is configured to store various types of data to support operations on the electronic device 1800. Examples of such data include instructions for any application or method operating on the electronic device 1800, contact data, phone book data, messages, pictures, videos, etc. The memory 1804 can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[0152] The power supply component 1806 provides power to the various components of the electronic device 1800. The power supply component 1806 may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power to the electronic device 1800.

[0153] The multimedia component 1808 includes a display screen that provides an output interface between the electronic device 1800 and the user. In some embodiments, the multimedia component 1808 includes a front camera and / or a rear camera. When the electronic device 1800 is in an operating mode, such as a shooting mode or a video mode, the front camera and / or the rear camera can receive external multimedia data. Each front camera and rear camera can be a fixed optical lens system or have a focal length and optical zoom capability.

[0154] The audio component 1810 is configured to output and / or input audio signals. For example, the audio component 1810 includes a microphone (MIC), and when the electronic device 1800 is in an operation mode, such as a call mode, a recording mode, and a voice recognition mode, the microphone is configured to receive an external audio signal. The received audio signal can be further stored in the memory 1804 or sent via the communication component 1818. In some embodiments, the audio component 1810 also includes a speaker for outputting audio signals.

[0155] I / O interface 1812 provides an interface between processing component 1802 and peripheral interface modules, such as keyboards, click wheels, buttons, etc. These buttons may include but are not limited to: home button, volume button, start button, and lock button.

[0156] The sensor assembly 1816 includes one or more sensors for providing various aspects of status assessment for the electronic device 1800. For example, the sensor assembly 1816 can detect the open / closed state of the electronic device 1800, the relative positioning of components, such as the display and keypad of the electronic device 1800, and the sensor assembly 1816 can also detect the position change of the electronic device 1800 or a component of the electronic device 1800, the presence or absence of user contact with the electronic device 1800, the orientation or acceleration / deceleration of the electronic device 1800, and the temperature change of the electronic device 1800. The sensor assembly 1816 may include a proximity sensor configured to detect the presence of a nearby object without any physical contact. The sensor assembly 1816 may also include an optical sensor, such as a CMOS or CCD image sensor, for use in imaging applications. In some embodiments, the sensor assembly 1816 may also include an accelerometer, a gyroscope sensor, a magnetic sensor, a pressure sensor, or a temperature sensor.

[0157] The communication component 1818 is configured to facilitate wired or wireless communication between the electronic device 1800 and other devices. The electronic device 1800 can access a wireless network based on a communication standard, such as Wi-Fi, 2G, 3G, 4G, 5G or 6G, or a combination thereof. In an exemplary embodiment, the communication component 1818 receives a broadcast signal or broadcast-related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component 1818 also includes a near field communication (NFC) module to facilitate short-range communication. For example, the NFC module can be implemented based on radio frequency identification (RFID) technology, infrared data association (IrDA) technology, ultra-wideband (UWB) technology, Bluetooth (BT) technology and other technologies.

[0158] In an exemplary embodiment, the electronic device 1800 may be implemented by one or more application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors, or other electronic components.

[0159] Obviously, the above embodiments are merely examples for the purpose of clear explanation, and are not intended to limit the embodiments. For those skilled in the art, other different forms of changes or modifications can be made based on the above description. It is not necessary and impossible to list all the embodiments here. The obvious changes or modifications derived therefrom are still within the scope of protection of the present invention.

Claims

1. An application debugging method, characterized in that: Applied to the compiling end, the method includes: Parsing the compiled code of the target application to obtain the element code of each page element in the page structure of the target application; According to the element code of each page element, a preset operation event is configured for each page element, so that when the preset operation event is executed on the page element, pre-configured debugging information corresponding to the page element is displayed; Generate a target installation file of the target application according to the element code of each page element after configuring the preset operation event, and send the target installation file to the running end so that the running end installs the target application according to the target installation file.

2. The method according to claim 1, characterized in that The step of configuring a preset operation event for each page element according to the element code of each page element includes: Determine the debugging information corresponding to each page element according to the element code of each page element; The preset operation event and the debugging information are configured in the element code of each page element.

3. The method according to claim 1, characterized in that: The step of generating the target installation file of the target application according to the element code of each page element after configuring the preset operation event includes: Packaging is performed according to the element code of each page element after the preset operation event is configured to obtain an installation package of the target application; The target installation file is obtained by configuring the installation package with preset identification information; the preset identification information is used to trigger the operation of the running end to call the target system interface.

4. The method according to any one of claims 1 to 3, characterized in that: The preset operation event includes a long press event, and the debugging information includes size information and / or position information of a page element.

5. An application debugging method, characterized in that: Applied to the operating end, the method includes: Receiving a target installation file sent by a compiling end, and installing a target application according to the target installation file, wherein the target installation file is obtained by the compiling end through the method according to any one of claims 1 to 4; In response to receiving a preset operation event for a page element of the target application, debugging information corresponding to the page element is displayed.

6. The method according to claim 5, characterized in that Also includes: In response to parsing the preset identification information in the target installation file of the target application, calling the target system interface corresponding to the preset identification information to obtain target configuration information; the target configuration information includes memory information and / or display frame rate information of the running terminal; Display the target configuration information.

7. The method according to claim 5, characterized in that The running end includes a mobile terminal and a wearable device, and the mobile terminal establishes a wireless communication connection with the wearable device; the receiving of the target installation file sent by the compiling end and installing the target application according to the target installation file includes: The mobile terminal receives the target installation file sent by the compiling end, and sends the target installation file to the wearable device; The wearable device installs the target application according to the target installation file.

8. An application debugging device, characterized in that: Applied to the compiling end, the device comprises: A code parsing module is configured to parse the compiled code of the target application to obtain the element code of each page element in the page structure of the target application; An event configuration module is configured to configure a preset operation event for each page element according to an element code of each page element, so that when the preset operation event is executed on the page element, pre-configured debugging information corresponding to the page element is displayed; The file sending module is configured to generate a target installation file of the target application according to the element code of each page element after configuring the preset operation event, and send the target installation file to the running end so that the running end installs the target application according to the target installation file.

9. An application debugging device, characterized in that: Applied to the operating end, the device comprises: A file receiving module, configured to receive a target installation file sent by a compiling end, and install a target application according to the target installation file, wherein the target installation file is obtained by the compiling end through the method according to any one of claims 1 to 4; The information display module is configured to display debugging information corresponding to the page element in response to receiving a preset operation event for the page element of the target application.

10. An electronic device, characterized in that: include: processor; as well as A memory storing computer instructions, wherein the computer instructions are used to enable the processor to execute the method according to any one of claims 1 to 4, or to execute the method according to any one of claims 5 to 7.

11. A storage medium, characterized in that: Computer instructions are stored, and the computer instructions are used to make a computer execute the method according to any one of claims 1 to 4, or execute the method according to any one of claims 5 to 7.

Images