Software debugging method and device, electronic equipment and storage medium

Abstract

The invention provides a software debugging method and device, electronic equipment and a storage medium, and relates to the technical field of computers. The method comprises the following steps: acquiring a debugging configuration instruction for target software, wherein the debugging configuration instruction is used for configuring an acquisition path of a target debugging file; generating a target debugging parameter according to the debugging configuration instruction; and based on the target debugging parameter, calling the preset engine to run and display the debugging effect of the target software, so that the target debugging file needing to be debugged can be specified through the debugging configuration instruction, and the debugging landing condition of the target software is locally searched by calling the preset engine, so that rapid debugging is realized, a software packaging link is omitted, and the debugging efficiency is improved. The debugging process can be simplified, the debugging efficiency can be improved, and the debugging cost can be reduced.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a software debugging method, device, electronic device and storage medium. Background Art

[0002] With the rapid development of Internet technology and the people's growing demand for entertainment and culture, the development of games has entered a new era. Game developers need to develop various types of games to meet the gaming needs of different players.

[0003] In the prior art, during the development of a game project, art designers are often required to splice UI resources in the game engine and then import them into the game package through a program before observing their actual implementation. If there is a position deviation, the art designer is required to manually adjust it again and then package and proofread it.

[0004] It can be seen that the existing debugging of UI resources requires the cooperation of multiple functional departments such as the UI resource design department and the game package development department. Therefore, the debugging process is relatively cumbersome and time-consuming. Summary of the invention

[0005] The purpose of this application is to provide a software debugging method, device, electronic device and storage medium to address the deficiencies in the above-mentioned prior art, which eliminates the software packaging process, can not only simplify the debugging process and improve debugging efficiency, but also reduce debugging costs.

[0006] To achieve the above purpose, the technical solution adopted in the embodiment of the present application is as follows:

[0007] In a first aspect, the present invention provides a software debugging method, the method comprising:

[0008] Obtaining a debugging configuration instruction for the target software, wherein the debugging configuration instruction is used to configure an acquisition path for the target debugging file;

[0009] Generate target debugging parameters according to the debugging configuration instructions;

[0010] Based on the target debugging parameters, a preset engine is called to run and display the debugging effect of the target software.

[0011] In a second aspect, the present invention provides a software debugging device, comprising:

[0012] An acquisition module, used to acquire a debugging configuration instruction for a target software, wherein the debugging configuration instruction is used to configure an acquisition path for a target debugging file;

[0013] A generation module, used for generating target debugging parameters according to the debugging configuration instruction;

[0014] The running module is used to call a preset engine to run and display the debugging effect of the target software based on the target debugging parameters.

[0015] In a third aspect, the present invention provides an electronic device, comprising: a processor, a storage medium and a bus, wherein the storage medium stores machine-readable instructions executable by the processor, and when the electronic device is running, the processor communicates with the storage medium via the bus, and the processor executes the machine-readable instructions to perform the steps of the software debugging method as described in any of the aforementioned implementations.

[0016] In a fourth aspect, the present invention provides a computer-readable storage medium having a computer program stored thereon, and when the computer program is executed by a processor, the steps of the software debugging method as described in any of the aforementioned implementation modes are executed.

[0017] The beneficial effects of this application are:

[0018] The software debugging method, device, electronic device and storage medium provided in the embodiments of the present application include: obtaining debugging configuration instructions for target software, the debugging configuration instructions are used to configure the acquisition path of the target debugging file; generating target debugging parameters according to the debugging configuration instructions; based on the target debugging parameters, calling a preset engine to run and display the debugging effect of the target software, so that the target debugging file that needs to be debugged can be specified through the debugging configuration instructions, and the debugging implementation status of the target software can be checked locally by calling the preset engine, so as to realize fast debugging and eliminate the software packaging link, which can not only simplify the debugging process and improve the debugging efficiency, but also reduce the debugging cost. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings required for use in the embodiments will be briefly introduced below. It should be understood that the following drawings only show certain embodiments of the present application and therefore should not be regarded as limiting the scope. For ordinary technicians in this field, other related drawings can be obtained based on these drawings without paying creative work.

[0020] Figure 1 A flowchart of a software debugging method provided in an embodiment of the present application;

[0021] Figure 2 A flowchart of another software debugging method provided in an embodiment of the present application;

[0022] Figure 3 A flowchart of another software debugging method provided in an embodiment of the present application;

[0023] Figure 4A flowchart of another software debugging method provided in an embodiment of the present application;

[0024] Figure 5 A flowchart of another software debugging method provided in an embodiment of the present application;

[0025] Figure 6 A schematic diagram of an interface of a debugging tool provided in an embodiment of the present application;

[0026] Figure 7 A schematic diagram of an interface of another debugging tool provided in an embodiment of the present application;

[0027] Figure 8 A schematic diagram of an interface of another debugging tool provided in an embodiment of the present application;

[0028] Fig. 9 A schematic diagram of the functional modules of a software debugging device provided in an embodiment of the present application;

[0029] Fig.10 A schematic diagram of the structure of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0030] In order to make the purpose, technical solution and advantages of the embodiments of the present application clearer, the technical solution in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, rather than all the embodiments. The components of the embodiments of the present application described and shown in the drawings here can be arranged and designed in various different configurations.

[0031] Therefore, the following detailed description of the embodiments of the present application provided in the accompanying drawings is not intended to limit the scope of the present application for which protection is sought, but merely represents selected embodiments of the present application. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in the field without creative work are within the scope of protection of the present application.

[0032] It should be noted that similar reference numerals and letters denote similar items in the following drawings, and therefore, once an item is defined in one drawing, further definition and explanation thereof is not required in subsequent drawings.

[0033] In related technologies, the debugging process of a game project often requires the cooperation of multiple functional departments such as the UI resource design department and the game package development department. Therefore, the debugging process is relatively cumbersome and time-consuming.

[0034] In view of this, an embodiment of the present application provides a software debugging method, the application of which can simplify the debugging process, improve debugging efficiency, and reduce debugging costs.

[0035] Figure 1 A flowchart of a software debugging method provided in an embodiment of the present application is provided. The execution subject of the method may be an electronic device such as a computer, a server, a processor, etc. Figure 1 As shown, the method may include:

[0036] Step 101: Obtain a debugging configuration instruction for a target software, where the debugging configuration instruction is used to configure an acquisition path for a target debugging file.

[0037] Optionally, the target software may be chat software, game software, shopping software, banking software, food delivery software, etc., which is not limited here.

[0038] The debugging configuration instruction is used to configure the acquisition path of the target debugging file, that is, to configure the acquisition path of the target debugging file to be debugged. Optionally, the debugging configuration instruction can be generated by a preset code, a preset control, or a preset configuration script, etc., which is not limited here.

[0039] In some embodiments, the target debugging file may include: UI resources, program files, script files, configuration files, data files, other supporting files, etc., which are not limited here. Optionally, the file type of the target debugging file may include uiprefab and nprefab, but is not limited thereto. The file type may be flexibly set according to the actual application scenario.

[0040] Taking game software as an example, game UI resources may include all images, audio, video and other media files used in the game, such as textures, models, animations, sound effects, etc.; game program files may include the game's executable files, that is, the program code used to run the game; game configuration files may include various configuration information of the game, such as game settings, archive information, user preferences, etc.; game data files may include various data files required in the game, such as level map data, game props data, character attribute data, etc.; game script files may include logic scripts, interface scripts, event scripts, etc. in the game, which are used to control the behavior and interaction of the game. Other supporting files in the game may include runtime libraries, plug-ins, third-party tools and other support files required by some games.

[0041] Step 102: Generate target debugging parameters according to the debugging configuration instructions.

[0042] Among them, based on the debugging configuration instruction, corresponding target debugging parameters can be generated, and the target debugging parameters can be used as a basis for subsequent debugging of the target software. The target debugging parameters may include: file information of the target debugging file indicated by the debugging configuration instruction, which may include but is not limited to: the acquisition path of the target debugging file, the version number of the target debugging file, the identification of the target debugging file, and the calling method of the target debugging file.

[0043] Step 103: Based on the target debugging parameters, call the preset engine to run and display the debugging effect of the target software.

[0044] Among them, the preset engine has the function of running and displaying the target software. Optionally, the preset engine can be a game engine or a software development engine for other application scenarios, which is not limited here. In order to better understand the present application, the following example takes the preset engine as a game engine as an example for explanation.

[0045] Optionally, the generated target debugging parameters can be used as running parameters of the preset engine. For example, when running the preset engine, the target debugging file indicated by the target debugging parameters can be called for execution. The debugging effect of the target software can be displayed through execution, thereby realizing that the target debugging file to be debugged can be specified through the debugging configuration instruction, and the debugging implementation status of the target software can be checked locally by calling the preset engine to achieve fast debugging, eliminating the software packaging link, which can not only simplify the debugging process and improve debugging efficiency, but also reduce debugging costs.

[0046] It is understandable that for UI resource designers, if UI resources change, by applying the embodiments of the present application, they can check the resource implementation status of the target software in a timely manner.

[0047] In summary, an embodiment of the present application provides a software debugging method, which includes: obtaining a debugging configuration instruction for a target software, the debugging configuration instruction is used to configure an acquisition path for a target debugging file; generating a target debugging parameter according to the debugging configuration instruction; based on the target debugging parameter, calling a preset engine to run and display the debugging effect of the target software, thereby realizing that the target debugging file to be debugged can be specified through the debugging configuration instruction, and the debugging implementation status of the target software can be checked locally by calling the preset engine, thereby realizing fast debugging and eliminating the software packaging link, which can not only simplify the debugging process and improve debugging efficiency, but also reduce debugging costs.

[0048] Figure 2 A flowchart of another software debugging method provided in an embodiment of the present application. Figure 2 As shown, the above generates target debugging parameters according to the debugging configuration instructions, including:

[0049] Step 201: Obtain adjustment parameters for display resolution of target software.

[0050] Step 202: Generate target debugging parameters according to the debugging configuration instructions and adjustment parameters.

[0051] It is understandable that when the target software is installed in different devices, it will be affected by the resolution of the target software. If the resolution setting is not appropriate, there will be a situation where information or buttons are blocked, affecting user reading and operation. Therefore, in order to make the target software display normally on different display devices, or to meet the user's personalized preference for interface size, the display resolution of the target software can be adjusted during the debugging process, thereby avoiding the situation where the resolution of different devices is not compatible, and improving the applicability of the method of the present application.

[0052] Optionally, the adjustment parameters for the display resolution of the target software may be generated by preset instructions, preset controls, etc., which are not limited here and may be flexibly set according to actual application scenarios.

[0053] Figure 3 A flowchart of another software debugging method provided in an embodiment of the present application. Figure 3 As shown, in an optional implementation, the above-mentioned calling the preset engine to run and display the debugging effect of the target software based on the target debugging parameters includes:

[0054] Step 301: Based on the target debugging parameters, obtain at least one of the following target debugging files: a first UI resource, a first UI package.

[0055] The first UI resource includes at least part of the UI resources corresponding to the target software, and the first UI package includes at least part of the program code corresponding to the target software.

[0056] Optionally, the first UI resource may be a UI resource that needs to be debugged, or it may be understood as a new version of UI resource, which may include at least one UI resource under one or more user interfaces corresponding to the target software, wherein the types of UI resources may include: images, audio, video and other media files, such as textures, models, animations, sound effects, etc., which are not limited here.

[0057] In some embodiments, the first UI package may be a UI package that needs to be debugged, or it may be understood as a new UI package, which may include: program files, script files, configuration files, data files, other supporting files and other types of program codes, wherein the program code may call UI resources to display the corresponding user interface.

[0058] Based on the above description, it can be understood that, according to the target debugging parameter used to indicate the file information of the target debugging file, the corresponding target debugging file can be obtained. The target debugging file may be the first UI resource and / or the first UI package.

[0059] Step 302: Call the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software.

[0060] Optionally, the preset engine may include a startup file, which may be used to start running the preset engine. After the preset engine is started, at least one target debugging file may be called to display the debugging effect of the target software. It is understandable that at this time, according to the debugging effect of the target software, it can be determined whether the target debugging file meets the preset design requirements. If it does, it is determined that the debugging is successful. If it does not, the target debugging file can be further adjusted and optimized.

[0061] It can be seen that the embodiments of the present application can be applied to the version update scenario of the target software, can achieve rapid debugging, and eliminate the software packaging link, which can not only simplify the debugging process and improve debugging efficiency, but also reduce debugging costs.

[0062] In an optional implementation, the above-mentioned calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes:

[0063] Based on the second file set preconfigured by the preset engine, a startup file in the preset engine is called to run at least one target debugging file to display the debugging effect of the target software.

[0064] Optionally, the preset engine may be preconfigured with a second file set, which may include: a second UI resource and a second UI package, the second UI resource including all UI resources corresponding to the target software, and the second UI package including all program codes corresponding to the target software.

[0065] In some embodiments, the second file set can be understood as a file set of an old version corresponding to the target software. It can be understood that, based on the second file set, calling the startup file in the preset engine can run and display the old version effect of the target software.

[0066] In combination with the foregoing description, at least one target debugging file may include: new UI resources and / or new program codes that need to be debugged, wherein, considering that the target debugging file may not be complete enough to run and display the target software, for example, in a scenario of local debugging, therefore, it is possible to combine the second file set preconfigured by the preset engine to run and display the debugging effect of the target software.

[0067] By applying the embodiment of the present application, it is possible to locally debug the target software in combination with the second file set preconfigured by the preset engine, thereby improving the applicability of the method of the present application.

[0068] Figure 4 A flowchart of another software debugging method provided in an embodiment of the present application. Figure 4 As shown, the second file set preconfigured based on the preset engine calls the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software, including:

[0069] Step 401: Call the startup file of the preset engine to determine the target debugging file identifier, where the target debugging file identifier includes: a target UI resource identifier and a target program code identifier.

[0070] Step 402: Determine a target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier.

[0071] Step 403: Determine the target program code in the first UI package and / or the second UI package according to the target program code identifier.

[0072] Step 404: Load the target UI resources and target program code through the startup file to run and display the debugging effect of the target software.

[0073] Among them, the startup file can specifically indicate the UI resource identifier, program code identifier, and the calling of each file that need to be called during the operation of the target software. Therefore, the target UI resource identifier and / or target code identifier that need to be called during the operation of the target software can be determined based on the startup file.

[0074] For the determined target UI resource identifier, the corresponding target UI resource can be determined from the first UI resource and / or the second UI resource; for the determined target program code identifier, the corresponding target program code can be determined from the first UI package and / or the second UI package.

[0075] It is understandable that, based on the determined target UI resources and target program code, the startup file can load the target UI resources and target program code according to a preset loading order to run and display the debugging effect of the target software.

[0076] Optionally, during specific loading, you can refer to the following loading logic: taking the determination of the target program code as an example, according to the target program code identifier, first determine whether the first UI package includes the target program code. If it is included, the startup file can load the target program code from the first UI package; if it is not included, the target program code is loaded from the second UI package, which can achieve priority calling of the first UI package, and has the characteristics of simple design and convenient debugging.

[0077] Figure 5 A flowchart of another software debugging method provided in an embodiment of the present application. Figure 5 As shown, the above-mentioned determining the target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier includes:

[0078] Step 501: Based on the target UI resource identifier, find out whether the first UI resource includes the target UI resource.

[0079] Step 502: If not included, search for the target UI resource from the second UI resource.

[0080] Optionally, if the second UI resource corresponds to an old version and the first UI resource corresponds to a new version, that is, the version that needs to be debugged, when searching for the target UI resource based on the target UI resource identifier, the first UI resource can be searched first, and if it is not found, the second UI resource is searched again, so that the first UI resource can be called first, which has the characteristics of simple design and convenient debugging.

[0081] In an optional embodiment, the above method further includes:

[0082] If the first UI resource does not include the target UI resource, the version control system of the preset engine is called according to the target UI resource identifier to obtain the target UI resource, wherein the version control system pre-stores at least some historical versions of UI resources.

[0083] Optionally, in some embodiments, a version control system may be deployed in the preset engine, and the version control system has the function of managing different versions of UI resources and program codes.

[0084] In some embodiments, the version control system may pre-store at least some historical versions of UI resources. Then, when the first UI resource does not include the target UI resource, the target UI resource may be acquired through the version control system according to the target UI resource identifier.

[0085] For example, let the target resource be identified as M, the first UI resource corresponds to the UI resource of version V3 (i.e., the new version), which includes at least part of the UI resources corresponding to the target software, and the second UI resource corresponds to the UI resource of version V2 (i.e., the old version), which includes all the UI resources corresponding to the target software; the version control system can pre-store at least part of the UI resources of the historical version, for example, it can store the third file set (including the third UI resource and the third UI package body) and the second file set (including the second UI resource and the second UI package body). Among them, the third UI resource corresponds to the UI resource of version V1, the third UI package body corresponds to the UI package body of version V1, and the version levels V1, V2 and V3 are increased in sequence.

[0086] Optionally, when the first UI resource does not include the target UI resource M, the target UI resource M can be searched from the second UI resource; or, the target UI resource M can be obtained from the version control system of the preset engine according to the target UI resource identifier.

[0087] It is worth noting that if the target UI resource M is obtained through the version control system of the preset engine, the target UI resource M can be obtained from the UI resource of the latest version level in the version control system. That is, when the third UI resource and the second UI resource both include the target UI resource M, the target UI resource M can be obtained from the second UI resource with a higher version level. Of course, the specific acquisition method is not limited to this and can be flexibly set according to the actual application scenario.

[0088] In summary, combined with the acquisition method of the above step 502, when the target UI resource is not included in the first UI resource, you can choose to search and obtain the target UI resource from the second UI resource, or, according to the target UI resource identifier, obtain the target UI resource through the version control system. It can be seen that the embodiment of the present application provides a variety of methods for obtaining the target UI resource, and the appropriate method can be selected according to the actual application scenario, which can improve the flexibility of the method of the present application.

[0089] In an optional embodiment, the above method further includes:

[0090] Submit the first file set to the version control system of the preset engine, and compare the version differences between the first file set and the second file set through the version control system, and output the file identifiers of the first file set that are deleted or modified relative to the second file set. The first file set includes: a first UI resource and a first UI package.

[0091] Optionally, the version control system has the function of managing different versions of UI resources and program codes. Optionally, the first file set can be submitted to the version control system of the preset engine.

[0092] Among them, for UI resources, the first UI resource and the second UI resource can be scanned separately through the version control system, and the version difference between the two can be output. Optionally, the resource identifier of the first UI resource that is deleted or modified relative to the second UI resource can be output; for UI packages, the first UI package and the second UI package can be scanned separately through the version control system, and the version difference between the two can be output. Optionally, the program code identifier of the first UI package that is deleted or modified relative to the second UI package can be output.

[0093] Of course, in some embodiments, the deleted files can also be formatted, such as backed up, converted, etc., by the version control system to ensure that the data is properly managed. For example, the deleted files can be backed up, converted to other formats, or other necessary processing can be performed by a preset management script or preset management tool in the version control system.

[0094] Optionally, a version control system can be set up to monitor resource references in the UI package. Once a UI resource change or a reference omission is detected, the detection information can be organized and output into a readable text file or other format for further analysis and processing by developers. For example, a report or log can be generated to describe the resource changes.

[0095] In summary, by setting up a version control system, you can automatically detect and process deleted program code and check resource references, which can greatly reduce the workload of developers manually handling resource changes and improve the efficiency of resource management. It also reduces human intervention, reduces the risk of human errors and human management costs, and improves the accuracy of resource management and project development efficiency. And by setting up a version control system, it can also help developers better track and manage resource changes to ensure the clarity and standardization of the code base.

[0096] Figure 6 A schematic diagram of an interface of a debugging tool provided in an embodiment of the present application. In an optional implementation, the above-mentioned obtaining of debugging configuration instructions for the target software includes:

[0097] The debugging configuration instructions for the target software are obtained through a preset debugging tool, wherein the preset debugging tool includes at least one of the following debugging controls: a first selection control for the directory where the first file set is located, a second selection control for the directory where the second file set is located, and an engine call control.

[0098] The first file set includes: a first UI resource and a first UI package, and the second file set includes: a second UI resource and a second UI package.

[0099] like Figure 6As shown, optionally, the directory where the first file set is located can be specified through the first selection control 10, that is, the acquisition path of the target debugging file can be configured, the directory where the second file set is located can be specified through the second selection control 20, and the startup file of the preset engine can be specified through the engine call control 30. In some embodiments, the parent directory of the first file set and the second file set can be the same.

[0100] For example, the folders corresponding to the first file set and the second file set are res1 and res2, and the parent directories of res1 and res2 are: D\artist\tools\yinqing\master; wherein res1 includes a first folder assets1 for storing the first UI resources and a second folder paefabs1 for storing the first UI package, assets1 includes at least part of the UI resources corresponding to the target software, and paefabs1 includes at least part of the program code corresponding to the target software; res2 includes a third folder assets2 for storing the second UI resources and a fourth folder paefabs2 for storing the first UI package, wherein assets2 includes all UI resources corresponding to the target software; paefabs2 includes all program codes corresponding to the target software.

[0101] By applying the embodiments of the present application, it is possible to generate debugging configuration instructions and perform debugging by triggering debugging controls, which is intuitive and simple, can lower the debugging threshold, and improve the applicability of the method of the present application.

[0102] Figure 7 A schematic diagram of an interface of another debugging tool provided in an embodiment of the present application. In an optional implementation, the preset debugging tool further includes a preset debugging window and at least one of the following operation controls: add control, delete control, clear control;

[0103] Wherein, a control is added, which can determine the first target program code in the first UI package in response to the first trigger operation, and display the acquisition path of the first target program code in the preset debugging window;

[0104] A deletion control, capable of deleting the acquisition path of the second target debugging file in response to a selection operation of at least one acquisition path of the second target program code in the preset debugging window;

[0105] The clear control can cancel the display of all acquisition paths in the preset debugging window in response to the third trigger operation.

[0106] The operation control may be understood as a sub-control of the first selection control, and the operation control may be used to refine the debugging scope.

[0107] like Figure 7 As shown, optionally, a first trigger operation such as single-click, double-click, long press, etc. can be used to add the control 50. In response to the first trigger operation, the folder corresponding to the first UI package can be entered, and any first target program code can be selected in the folder. At this time, the acquisition path of the first target program code can be displayed in the preset debugging window 40.

[0108] Optionally, the delete control 60 can be acted on by a second trigger operation such as single-click, double-click, and long press, and in response to the second trigger operation, at least one acquisition path of the second target program code in the preset debugging window 40 can be selected for deletion; for the clear control 70, the clear control can be acted on by a third trigger operation such as single-click, double-click, and long press, and in response to the third trigger operation, all acquisition paths in the preset debugging window 40 can be canceled.

[0109] By using the embodiments of the present application, the target program code that needs to be debugged can be flexibly specified through the setting of the operation control, the debugging scope can be refined, and precise debugging can be achieved.

[0110] In an optional embodiment, if Figure 7 As shown, the preset debugging tool also includes: preset input controls, and the above method also includes:

[0111] In response to a triggering operation of copying at least one acquisition path of the third target program code to a preset input control, the acquisition path of the third target program code is displayed in a preset debugging window.

[0112] like Figure 7 As shown, the setting of the preset input control 11 can provide the user with another way to refine the debugging scope. Specifically, at least one acquisition path of the third target program code can be pasted into the input box 12 indicated by the preset input control 11 by copying and pasting, without manually entering a separator. In response to the trigger operation, the acquisition path of the third target program code can be synchronously displayed in the preset debugging.

[0113] The embodiments of the present application provide a variety of ways to refine the debugging scope, which can improve the flexibility of the method of the present application.

[0114] In an optional embodiment, if Figure 7 As shown, the preset debugging tool also includes: disabling the debugging control, and the above method also includes:

[0115] In response to the triggering operation of disabling the debugging control, the startup file of the preset engine is called based on the second UI package to display the debugging effect of the target software.

[0116] like Figure 7As shown, the deactivate debugging control 80 is used to indicate whether to stop debugging the program code. Optionally, if it is indicated to stop debugging, the startup file of the preset engine is called based on the program code in the second UI package to display the debugging effect of the target software, thereby realizing the flexible activation of the debugging function for the program code, which can improve the applicability of the method of the present application.

[0117] Figure 8 A schematic diagram of the interface of another debugging tool provided in an embodiment of the present application. Fig. 9 A flowchart of another software debugging method provided in an embodiment of the present application is shown below. Figure 8 As shown, the engine calling control 30 includes: a third selection control 31 and an engine running control 32; the above-mentioned calling the startup file in the preset engine to run and display the debugging effect of the target software according to at least one target debugging file includes:

[0118] In response to the triggering operation of the third selection control, a startup file is determined; based on at least one target debugging file and a startup file, in response to the triggering operation of the engine running control, the startup file in the preset engine is called to run and display the debugging effect of the target software.

[0119] like Figure 8 As shown, the third selection control 31 can be used to indicate the path for obtaining the startup file. Optionally, the selection control can be acted on by triggering operations such as single-clicking, double-clicking, and long pressing. In response to the triggering operation, the startup file can be specified; based on the selection of the startup file, the engine running control 32 can be acted on by triggering methods such as single-clicking, double-clicking, and long pressing. In response to the triggering method, the startup file can be called to run and display the debugging effect of the target software, which realizes that the preset engine can be called by the selection control in the preset debugging tool and the preset engine can be started by the engine running control without specifically opening the preset engine, which can simplify the debugging process and improve the debugging efficiency compared to the prior art.

[0120] Fig. 9 This is a functional module diagram of a software debugging device provided in an embodiment of the present application. The basic principle and technical effects of the device are the same as those of the corresponding method embodiment described above. For the sake of brief description, the parts not mentioned in this embodiment can be referred to the corresponding contents in the method embodiment. Fig. 9 As shown, the software debugging device 100 includes:

[0121] The acquisition module 110 is used to acquire the debugging configuration instruction for the target software, wherein the debugging configuration instruction is used to configure the acquisition path of the target debugging file;

[0122] A generating module 120, configured to generate target debugging parameters according to the debugging configuration instruction;

[0123] The running module 130 is used to call a preset engine to run and display the debugging effect of the target software based on the target debugging parameters.

[0124] In an optional implementation, the generating module 120 is specifically used to obtain adjustment parameters for the display resolution of the target software;

[0125] The target debugging parameters are generated according to the debugging configuration instructions and the adjustment parameters.

[0126] In an optional implementation, the running module 130 is specifically used to obtain at least one of the following target debugging files based on the target debugging parameters: a first UI resource, a first UI package; wherein the first UI resource includes at least part of the UI resource corresponding to the target software, and the first UI package includes at least part of the program code corresponding to the target software;

[0127] The startup file in the preset engine is called to run at least one target debugging file to display the debugging effect of the target software.

[0128] In an optional implementation, the running module 130 is specifically configured to call a startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software based on the second file set preconfigured by the preset engine;

[0129] The second file set includes: a second UI resource and a second UI package; the second UI resource includes all UI resources corresponding to the target software, and the second UI package includes all program codes corresponding to the target software.

[0130] In an optional implementation, the running module 130 is specifically used to call the startup file of the preset engine to determine the target debugging file identifier, and the target debugging file identifier includes: a target UI resource identifier and a target program code identifier;

[0131] Determine a target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier;

[0132] Determining a target program code in the first UI package and / or the second UI package according to the target program code identifier;

[0133] The target UI resource and the target program code are loaded through the startup file to run and display the debugging effect of the target software.

[0134] In an optional implementation manner, the running module 130 is specifically configured to search, based on the target UI resource identifier, whether the first UI resource includes the target UI resource;

[0135] If not included, the target UI resource is searched from the second UI resource.

[0136] In an optional implementation, the running module 130 is also used to: if the target UI resource is not included in the first UI resource, then according to the target UI resource identifier, call the version control system of the preset engine to obtain the target UI resource, wherein the version control system pre-stores at least some historical versions of UI resources.

[0137] In an optional embodiment, the debugging device also includes: a processing module, used to submit the first file set to the version control system of the preset engine, and compare the version differences between the first file set and the second file set through the version control system, and output the file identifiers of the first file set that are deleted or modified relative to the second file set, wherein the first file set includes: a first UI resource and a first UI package.

[0138] In an optional implementation, the acquisition module 110 is specifically used to acquire the debugging configuration instructions for the target software through a preset debugging tool, wherein the preset debugging tool includes at least one of the following debugging controls: a first selection control for the directory where the first file set is located, a second selection control for the directory where the second file set is located, and an engine call control;

[0139] The first file set includes: a first UI resource and a first UI package, and the second file set includes: a second UI resource and a second UI package.

[0140] In an optional embodiment, the preset debugging tool further includes a preset debugging window and at least one of the following operation controls: add control, delete control, clear control;

[0141] The adding control can determine the first target program code in the first UI package in response to the first trigger operation, and display the acquisition path of the first target program code in the preset debugging window;

[0142] The deletion control can delete the acquisition path of the second target program code in response to a selection operation of at least one acquisition path of the second target program code in the preset debugging window;

[0143] The clear control can cancel the display of all acquisition paths in the preset debugging window in response to a third trigger operation.

[0144] In an optional embodiment, the preset debugging tool also includes: a preset input control, and the device also includes: a response module for displaying the acquisition path of the third target program code in the preset debugging window in response to a trigger operation of copying at least one acquisition path of the third target program code to the preset input control.

[0145] In an optional implementation, the preset debugging tool also includes: disabling debugging controls, and the response module is further used to respond to a triggering operation on the disabling debugging controls, and based on the second UI package, call the startup file of the preset engine to display the debugging effect of the target software.

[0146] In an optional embodiment, the engine call control includes: a third selection control and an engine running control; the running module is specifically used to determine the startup file in response to a trigger operation on the third selection control; based on at least one of the target debugging files and the startup file, in response to a trigger operation on the engine running control, the startup file in the preset engine is called to run and display the debugging effect of the target software.

[0147] The above-mentioned device is used to execute the method provided by the aforementioned embodiment, and its implementation principle and technical effect are similar, which will not be repeated here.

[0148] The above modules may be one or more integrated circuits configured to implement the above methods, such as one or more application specific integrated circuits (ASICs), or one or more microprocessors, or one or more field programmable gate arrays (FPGAs). For another example, when a module is implemented in the form of a processing element scheduling program code, the processing element may be a general-purpose processor, such as a central processing unit (CPU) or other processor that can call program code. For another example, these modules may be integrated together and implemented in the form of a system-on-a-chip (SOC).

[0149] Fig.10 The present invention provides a schematic diagram of an electronic device structure, which can be integrated into a software debugging device. Fig.10As shown, the electronic device may include: a processor 210, a storage medium 220 and a bus 230, the storage medium 220 stores machine-readable instructions executable by the processor 210, when the electronic device is running, the processor 210 and the storage medium 220 communicate through the bus 230, and the processor 210 executes the machine-readable instructions to perform the following method embodiments:

[0150] Obtaining a debugging configuration instruction for the target software, wherein the debugging configuration instruction is used to configure an acquisition path for the target debugging file;

[0151] Generate target debugging parameters according to the debugging configuration instructions;

[0152] Based on the target debugging parameters, a preset engine is called to run and display the debugging effect of the target software.

[0153] In an optional implementation, generating target debugging parameters according to the debugging configuration instruction includes:

[0154] Obtaining adjustment parameters for the display resolution of the target software;

[0155] The target debugging parameters are generated according to the debugging configuration instructions and the adjustment parameters.

[0156] In an optional implementation, calling a preset engine to run and display the debugging effect of the target software based on the target debugging parameter includes:

[0157] Based on the target debugging parameter, obtaining at least one of the following target debugging files: a first UI resource, a first UI package; wherein the first UI resource includes at least part of the UI resource corresponding to the target software, and the first UI package includes at least part of the program code corresponding to the target software;

[0158] The startup file in the preset engine is called to run at least one target debugging file to display the debugging effect of the target software.

[0159] In an optional implementation, calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes:

[0160] Based on the second file set preconfigured by the preset engine, calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software;

[0161] The second file set includes: a second UI resource and a second UI package; the second UI resource includes all UI resources corresponding to the target software, and the second UI package includes all program codes corresponding to the target software.

[0162] In an optional implementation, the calling of a startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software based on the second file set preconfigured by the preset engine includes:

[0163] Calling the startup file of the preset engine to determine the target debugging file identifier, the target debugging file identifier includes: a target UI resource identifier and a target program code identifier;

[0164] Determine a target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier;

[0165] Determining a target program code in the first UI package and / or the second UI package according to the target program code identifier;

[0166] The target UI resource and the target program code are loaded through the startup file to run and display the debugging effect of the target software.

[0167] In an optional implementation, determining the target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier includes:

[0168] Based on the target UI resource identifier, searching whether the first UI resource includes the target UI resource;

[0169] If not included, the target UI resource is searched from the second UI resource.

[0170] In an optional embodiment, the above method further includes:

[0171] If the first UI resource does not include the target UI resource, then according to the target UI resource identifier, the version control system of the preset engine is called to obtain the target UI resource, wherein the version control system pre-stores at least some historical versions of UI resources.

[0172] In an optional embodiment, the above method further includes:

[0173] Submit the first file set to the version control system of the preset engine, and compare the version differences between the first file set and the second file set through the version control system, and output the file identifiers of the first file set that are deleted or modified relative to the second file set, wherein the first file set includes: a first UI resource and a first UI package.

[0174] In an optional implementation manner, the above-mentioned obtaining the debugging configuration instruction for the target software includes:

[0175] Obtaining debugging configuration instructions for the target software through a preset debugging tool, wherein the preset debugging tool includes at least one of the following debugging controls: a first selection control for a directory where a first file set is located, a second selection control for a directory where a second file set is located, and an engine call control;

[0176] The first file set includes: a first UI resource and a first UI package, and the second file set includes: a second UI resource and a second UI package.

[0177] In an optional embodiment, the preset debugging tool further includes a preset debugging window and at least one of the following operation controls: add control, delete control, clear control;

[0178] The adding control can determine the first target program code in the first UI package in response to the first trigger operation, and display the acquisition path of the first target program code in the preset debugging window;

[0179] The deletion control can delete the acquisition path of the second target program code in response to a selection operation of at least one acquisition path of the second target program code in the preset debugging window;

[0180] The clear control can cancel the display of all acquisition paths in the preset debugging window in response to a third trigger operation.

[0181] In an optional implementation, the preset debugging tool further includes: a preset input control, and the method further includes:

[0182] In response to a triggering operation of copying at least one acquisition path of a third target program code to the preset input control, the acquisition path of the third target program code is displayed in the preset debugging window.

[0183] In an optional implementation, the preset debugging tool further includes: disabling the debugging control, and the method further includes:

[0184] In response to the triggering operation of disabling the debugging control, the startup file of the preset engine is called based on the second UI package to display the debugging effect of the target software.

[0185] In an optional embodiment, the engine call control includes: a third selection control and an engine run control;

[0186] The calling of the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes:

[0187] In response to a triggering operation on the third selection control, determining the startup file;

[0188] Based on at least one of the target debugging files and the startup file, in response to a triggering operation on the engine running control, the startup file in the preset engine is called to run and display the debugging effect of the target software.

[0189] It should be noted that the specific implementation methods and technical effects of the above method embodiments can be found in the above related descriptions and will not be repeated here.

[0190] Optionally, the present application further provides a storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the following method embodiments are executed:

[0191] Obtaining a debugging configuration instruction for the target software, wherein the debugging configuration instruction is used to configure an acquisition path for the target debugging file;

[0192] Generate target debugging parameters according to the debugging configuration instructions;

[0193] Based on the target debugging parameters, a preset engine is called to run and display the debugging effect of the target software.

[0194] In an optional implementation, generating target debugging parameters according to the debugging configuration instruction includes:

[0195] Obtaining adjustment parameters for the display resolution of the target software;

[0196] The target debugging parameters are generated according to the debugging configuration instructions and the adjustment parameters.

[0197] In an optional implementation, calling a preset engine to run and display the debugging effect of the target software based on the target debugging parameter includes:

[0198] Based on the target debugging parameter, obtaining at least one of the following target debugging files: a first UI resource, a first UI package; wherein the first UI resource includes at least part of the UI resource corresponding to the target software, and the first UI package includes at least part of the program code corresponding to the target software;

[0199] The startup file in the preset engine is called to run at least one target debugging file to display the debugging effect of the target software.

[0200] In an optional implementation, calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes:

[0201] Based on the second file set preconfigured by the preset engine, calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software;

[0202] The second file set includes: a second UI resource and a second UI package; the second UI resource includes all UI resources corresponding to the target software, and the second UI package includes all program codes corresponding to the target software.

[0203] In an optional implementation, the calling of a startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software based on the second file set preconfigured by the preset engine includes:

[0204] Calling the startup file of the preset engine to determine the target debugging file identifier, the target debugging file identifier includes: a target UI resource identifier and a target program code identifier;

[0205] Determine a target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier;

[0206] Determining a target program code in the first UI package and / or the second UI package according to the target program code identifier;

[0207] The target UI resource and the target program code are loaded through the startup file to run and display the debugging effect of the target software.

[0208] In an optional implementation, determining the target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier includes:

[0209] Based on the target UI resource identifier, searching whether the first UI resource includes the target UI resource;

[0210] If not included, the target UI resource is searched from the second UI resource.

[0211] In an optional embodiment, the above method further includes:

[0212] If the first UI resource does not include the target UI resource, then according to the target UI resource identifier, the version control system of the preset engine is called to obtain the target UI resource, wherein the version control system pre-stores at least some historical versions of UI resources.

[0213] In an optional embodiment, the above method further includes:

[0214] Submit the first file set to the version control system of the preset engine, and compare the version differences between the first file set and the second file set through the version control system, and output the file identifiers of the first file set that are deleted or modified relative to the second file set, wherein the first file set includes: a first UI resource and a first UI package.

[0215] In an optional implementation manner, the above-mentioned obtaining the debugging configuration instruction for the target software includes:

[0216] Obtaining debugging configuration instructions for the target software through a preset debugging tool, wherein the preset debugging tool includes at least one of the following debugging controls: a first selection control for a directory where a first file set is located, a second selection control for a directory where a second file set is located, and an engine call control;

[0217] The first file set includes: a first UI resource and a first UI package, and the second file set includes: a second UI resource and a second UI package.

[0218] In an optional embodiment, the preset debugging tool further includes a preset debugging window and at least one of the following operation controls: add control, delete control, clear control;

[0219] The adding control can determine the first target program code in the first UI package in response to the first trigger operation, and display the acquisition path of the first target program code in the preset debugging window;

[0220] The deletion control can delete the acquisition path of the second target program code in response to a selection operation of at least one acquisition path of the second target program code in the preset debugging window;

[0221] The clear control can cancel the display of all acquisition paths in the preset debugging window in response to a third trigger operation.

[0222] In an optional implementation, the preset debugging tool further includes: a preset input control, and the method further includes:

[0223] In response to a triggering operation of copying at least one acquisition path of a third target program code to the preset input control, the acquisition path of the third target program code is displayed in the preset debugging window.

[0224] In an optional implementation, the preset debugging tool further includes: disabling the debugging control, and the method further includes:

[0225] In response to the triggering operation of disabling the debugging control, the startup file of the preset engine is called based on the second UI package to display the debugging effect of the target software.

[0226] In an optional embodiment, the engine call control includes: a third selection control and an engine run control;

[0227] The calling of the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes:

[0228] In response to a triggering operation on the third selection control, determining the startup file;

[0229] Based on at least one of the target debugging files and the startup file, in response to a triggering operation on the engine running control, the startup file in the preset engine is called to run and display the debugging effect of the target software.

[0230] It should be noted that the specific implementation methods and technical effects of the above method embodiments can be found in the above related descriptions and will not be repeated here.

[0231] Optionally, the present application further provides a computer program product, the computer program product comprising instructions, which, when executed on an electronic device, enables the electronic device to implement the following method embodiments:

[0232] Obtaining a debugging configuration instruction for the target software, wherein the debugging configuration instruction is used to configure an acquisition path for the target debugging file;

[0233] Generate target debugging parameters according to the debugging configuration instructions;

[0234] Based on the target debugging parameters, a preset engine is called to run and display the debugging effect of the target software.

[0235] In an optional implementation, generating target debugging parameters according to the debugging configuration instruction includes:

[0236] Obtaining adjustment parameters for the display resolution of the target software;

[0237] The target debugging parameters are generated according to the debugging configuration instructions and the adjustment parameters.

[0238] In an optional implementation, calling a preset engine to run and display the debugging effect of the target software based on the target debugging parameter includes:

[0239] Based on the target debugging parameter, obtaining at least one of the following target debugging files: a first UI resource, a first UI package; wherein the first UI resource includes at least part of the UI resource corresponding to the target software, and the first UI package includes at least part of the program code corresponding to the target software;

[0240] The startup file in the preset engine is called to run at least one target debugging file to display the debugging effect of the target software.

[0241] In an optional implementation, calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes:

[0242] Based on the second file set preconfigured by the preset engine, calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software;

[0243] The second file set includes: a second UI resource and a second UI package; the second UI resource includes all UI resources corresponding to the target software, and the second UI package includes all program codes corresponding to the target software.

[0244] In an optional implementation, the calling of a startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software based on the second file set preconfigured by the preset engine includes:

[0245] Calling the startup file of the preset engine to determine the target debugging file identifier, the target debugging file identifier includes: a target UI resource identifier and a target program code identifier;

[0246] Determine a target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier;

[0247] Determining a target program code in the first UI package and / or the second UI package according to the target program code identifier;

[0248] The target UI resource and the target program code are loaded through the startup file to run and display the debugging effect of the target software.

[0249] In an optional implementation, determining the target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier includes:

[0250] Based on the target UI resource identifier, searching whether the first UI resource includes the target UI resource;

[0251] If not included, the target UI resource is searched from the second UI resource.

[0252] In an optional embodiment, the above method further includes:

[0253] If the first UI resource does not include the target UI resource, then according to the target UI resource identifier, the version control system of the preset engine is called to obtain the target UI resource, wherein the version control system pre-stores at least some historical versions of UI resources.

[0254] In an optional embodiment, the above method further includes:

[0255] Submit the first file set to the version control system of the preset engine, and compare the version differences between the first file set and the second file set through the version control system, and output the file identifiers of the first file set that are deleted or modified relative to the second file set, wherein the first file set includes: a first UI resource and a first UI package.

[0256] In an optional implementation manner, the above-mentioned obtaining the debugging configuration instruction for the target software includes:

[0257] Obtaining debugging configuration instructions for the target software through a preset debugging tool, wherein the preset debugging tool includes at least one of the following debugging controls: a first selection control for a directory where a first file set is located, a second selection control for a directory where a second file set is located, and an engine call control;

[0258] The first file set includes: a first UI resource and a first UI package, and the second file set includes: a second UI resource and a second UI package.

[0259] In an optional embodiment, the preset debugging tool further includes a preset debugging window and at least one of the following operation controls: add control, delete control, clear control;

[0260] The adding control can determine the first target program code in the first UI package in response to the first trigger operation, and display the acquisition path of the first target program code in the preset debugging window;

[0261] The deletion control can delete the acquisition path of the second target program code in response to a selection operation of at least one acquisition path of the second target program code in the preset debugging window;

[0262] The clear control can cancel the display of all acquisition paths in the preset debugging window in response to a third trigger operation.

[0263] In an optional implementation, the preset debugging tool further includes: a preset input control, and the method further includes:

[0264] In response to a triggering operation of copying at least one acquisition path of a third target program code to the preset input control, the acquisition path of the third target program code is displayed in the preset debugging window.

[0265] In an optional implementation, the preset debugging tool further includes: disabling the debugging control, and the method further includes:

[0266] In response to the triggering operation of disabling the debugging control, the startup file of the preset engine is called based on the second UI package to display the debugging effect of the target software.

[0267] In an optional embodiment, the engine call control includes: a third selection control and an engine run control;

[0268] The calling of the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes:

[0269] In response to a triggering operation on the third selection control, determining the startup file;

[0270] Based on at least one of the target debugging files and the startup file, in response to a triggering operation on the engine running control, the startup file in the preset engine is called to run and display the debugging effect of the target software.

[0271] It should be noted that the specific implementation methods and technical effects of the above method embodiments can be found in the above related descriptions and will not be repeated here.

[0272] In the several embodiments provided in the present application, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic. For example, the division of units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0273] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0274] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of hardware plus software functional units.

[0275] The above-mentioned integrated unit implemented in the form of a software functional unit can be stored in a computer-readable storage medium. The above-mentioned software functional unit is stored in a storage medium, including a number of instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) or a processor (English: processor) to perform some steps of the methods of each embodiment of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (English: Read-Only Memory, abbreviated: ROM), random access memory (English: Random Access Memory, abbreviated: RAM), disk or optical disk and other media that can store program codes.

[0276] It should be noted that, in this article, relational terms such as "first" and "second" are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. In the absence of further restrictions, the elements defined by the sentence "comprise a ..." do not exclude the existence of other identical elements in the process, method, article or device including the elements.

[0277] The above are only preferred embodiments of the present application and are not intended to limit the present application. For those skilled in the art, the present application may have various changes and variations. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present application shall be included in the scope of protection of the present application. It should be noted that similar numbers and letters represent similar items in the following drawings, so once an item is defined in one drawing, it does not need to be further defined and explained in subsequent drawings. The above are only preferred embodiments of the present application and are not intended to limit the present application. For those skilled in the art, the present application may have various changes and variations. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present application shall be included in the scope of protection of the present application.

Claims

1. A software debugging method, It is characterized in that The method comprises: Obtaining a debugging configuration instruction for the target software, wherein the debugging configuration instruction is used to configure an acquisition path for the target debugging file; Generate target debugging parameters according to the debugging configuration instructions; Based on the target debugging parameters, a preset engine is called to run and display the debugging effect of the target software.

2. The method according to claim 1, It is characterized in that Generating target debugging parameters according to the debugging configuration instruction includes: Obtaining adjustment parameters for the display resolution of the target software; The target debugging parameters are generated according to the debugging configuration instructions and the adjustment parameters.

3. The method according to claim 1, It is characterized in that The step of calling a preset engine to run and display the debugging effect of the target software based on the target debugging parameter includes: Based on the target debugging parameter, obtaining at least one of the following target debugging files: a first UI resource, a first UI package; wherein the first UI resource includes at least part of the UI resource corresponding to the target software, and the first UI package includes at least part of the program code corresponding to the target software; The startup file in the preset engine is called to run at least one target debugging file to display the debugging effect of the target software.

4. The method according to claim 3, It is characterized in that The calling of the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes: Based on the second file set preconfigured by the preset engine, calling the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software; The second file set includes: a second UI resource and a second UI package; the second UI resource includes all UI resources corresponding to the target software, and the second UI package includes all program codes corresponding to the target software.

5. The method according to claim 4, It is characterized in that The step of calling a startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software based on the second file set preconfigured by the preset engine includes: Calling the startup file of the preset engine to determine the target debugging file identifier, the target debugging file identifier includes: a target UI resource identifier and a target program code identifier; Determine a target UI resource in the first UI resource and / or the second UI resource according to the target UI resource identifier; Determining a target program code in the first UI package and / or the second UI package according to the target program code identifier; The target UI resource and the target program code are loaded through the startup file to run and display the debugging effect of the target software.

6. The method according to claim 5, It is characterized in that The determining, according to the target UI resource identifier, a target UI resource in the first UI resource and / or the second UI resource includes: Based on the target UI resource identifier, searching whether the first UI resource includes the target UI resource; If not included, the target UI resource is searched from the second UI resource.

7. The method according to claim 6, It is characterized in that The method further comprises: If the first UI resource does not include the target UI resource, then according to the target UI resource identifier, the version control system of the preset engine is called to obtain the target UI resource, wherein the version control system pre-stores at least some historical versions of UI resources.

8. The method according to claim 7, It is characterized in that The method further comprises: Submit the first file set to the version control system of the preset engine, and compare the version differences between the first file set and the second file set through the version control system, and output the file identifiers of the first file set that are deleted or modified relative to the second file set, wherein the first file set includes: a first UI resource and a first UI package.

9. The method according to claim 3, It is characterized in that The step of obtaining the debugging configuration instruction for the target software includes: Obtaining debugging configuration instructions for the target software through a preset debugging tool, wherein the preset debugging tool includes at least one of the following debugging controls: a first selection control for a directory where a first file set is located, a second selection control for a directory where a second file set is located, and an engine call control; The first file set includes: a first UI resource and a first UI package, and the second file set includes: a second UI resource and a second UI package.

10. The method according to claim 9, It is characterized in that The preset debugging tool also includes a preset debugging window and at least one of the following operation controls: add control, delete control, clear control; The adding control can determine the first target program code in the first UI package in response to the first trigger operation, and display the acquisition path of the first target program code in the preset debugging window; The deletion control can delete the acquisition path of the second target program code in response to a selection operation of at least one acquisition path of the second target program code in the preset debugging window; The clear control can cancel the display of all acquisition paths in the preset debugging window in response to a third trigger operation.

11. The method according to claim 10, It is characterized in that The preset debugging tool also includes: preset input controls, and the method also includes: In response to a triggering operation of copying at least one acquisition path of a third target program code to the preset input control, the acquisition path of the third target program code is displayed in the preset debugging window.

12. The method according to claim 9, It is characterized in that The preset debugging tool further includes: disabling the debugging control, and the method further includes: In response to the triggering operation of disabling the debugging control, the startup file of the preset engine is called based on the second UI package to display the debugging effect of the target software.

13. The method according to claim 9, It is characterized in that The engine call control includes: a third selection control and an engine run control; The calling of the startup file in the preset engine to run at least one target debugging file to display the debugging effect of the target software includes: In response to a triggering operation on the third selection control, determining the startup file; Based on at least one of the target debugging files and the startup file, in response to a triggering operation on the engine running control, the startup file in the preset engine is called to run and display the debugging effect of the target software.

14. A software debugging device, It is characterized in that include: An acquisition module, used to acquire a debugging configuration instruction for a target software, wherein the debugging configuration instruction is used to configure an acquisition path for a target debugging file; A generation module, used for generating target debugging parameters according to the debugging configuration instruction; The running module is used to call a preset engine to run and display the debugging effect of the target software based on the target debugging parameters.

15. An electronic device, It is characterized in that include: A processor, a storage medium and a bus, wherein the storage medium stores machine-readable instructions executable by the processor, and when the electronic device is running, the processor communicates with the storage medium via the bus, and the processor executes the machine-readable instructions to perform the steps of the software debugging method as described in any one of claims 1-13.

16. A computer-readable storage medium, It is characterized in that The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the steps of the software debugging method according to any one of claims 1 to 13 are executed.

Images