CN110795353B - Quick application debugging method, device, equipment and storage medium - Google Patents
Quick application debugging method, device, equipment and storage medium Download PDFInfo
- Publication number
- CN110795353B CN110795353B CN201911040405.7A CN201911040405A CN110795353B CN 110795353 B CN110795353 B CN 110795353B CN 201911040405 A CN201911040405 A CN 201911040405A CN 110795353 B CN110795353 B CN 110795353B
- Authority
- CN
- China
- Prior art keywords
- target page
- repackaged
- running
- debugging
- page
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
Abstract
The invention discloses a debugging method, device, equipment and storage medium of a fast application, relating to the technical field of computers, wherein the method comprises the following steps: when the target page of the fast application is operated, reporting the debugging result of the target page; receiving a repackaged compiling file package, wherein the repackaged compiling file package is updated according to the debugging result; acquiring a path of a target page; and determining a script file acquired from the repackaged compiled file package according to the path of the target page, wherein the script file is used for running and displaying the target page. According to the method, when the fast application is debugged, after the repackaged compiling file package is received, the target page is directly operated and displayed in the operation side device by acquiring the path of the target page, other pages which are relied on before the target page is operated again are not needed, and the debugging efficiency is improved.
Description
Technical Field
The disclosure relates to the technical field of computers, and in particular relates to a debugging method, device and equipment for fast application and a storage medium.
Background
A fast app is an installation-free application that is rendered in a native environment using front-end technology development. The fast application can realize the 'point-and-use' capability of the application, and the step of downloading and installing the application by a user is omitted.
In the debugging process of the fast application, the compiling side device generates a compiling file package, sends the compiling file package to the running side device for running, and establishes debugging connection between the compiling side device and the running side device. The quick application corresponds to a plurality of pages in the running process: first page, page a, page B, … …, page X. If the developer needs to debug the page X, the running side device needs to run other pages (a first page, a page A, a page B and the like) on which the page X depends before running, and then the page X can be run, and the debugging result of the page X is fed back to the developer.
In the debugging process, a developer needs to perform page switching for a plurality of times to acquire the debugging result of the target page X, and the debugging efficiency is low.
Disclosure of Invention
The embodiment of the disclosure provides a quick application debugging method, device, equipment and storage medium, which can be used for solving the problems that in the debugging method provided by the related technology, a developer needs to perform page switching for a plurality of times to acquire a debugging result of a target page X and the debugging efficiency is low. The technical scheme is as follows:
According to one aspect of the present disclosure, there is provided a debugging method of a fast application, applied to a running side device running the fast application, the method including:
when the target page of the fast application is operated, reporting the debugging result of the target page;
receiving a repackaged compiling file package, wherein the repackaged compiling file package is updated according to the debugging result;
acquiring a path of a target page;
and determining a script file acquired from the repackaged compiled file package according to the path of the target page, wherein the script file is used for running and displaying the target page.
In an alternative example, obtaining the path of the target page includes: acquiring the identification of a target page from the self-running code in the repackaged compiled file package; acquiring a configuration file in the repackaged compiled file package, determining a path of the target page in the configuration file according to the identifier of the target page, wherein the configuration file contains the corresponding relationship between the identifier of the target page and the path of the target page; or directly acquiring the path of the target page from the self-running code in the repackaged compiled file package.
In an alternative example, the step of obtaining the path of the target page is performed when the fast application is in the hot-load debug mode; or executing the step of acquiring the path of the target page when the running side device is running the compiled file package with the same package name as the repackaged compiled file package; or when the fast application is in the hot load debugging mode and the running side device is running the compiled file package with the same package name as the repackaged compiled file package, executing the step of acquiring the path of the target page.
In an alternative example, the debug results of the target page are again reported.
According to one aspect of the present disclosure, there is provided a debugging method of a fast application, applied to a running side device running the fast application, the method including:
receiving a debugging result of a target page of the fast application;
generating a repackaged compiled file package, wherein the repackaged compiled file package comprises a configuration file, and the configuration file comprises a path of a target page;
and sending the repackaged compiled file package to the running side device running the fast application.
According to one aspect of the present disclosure, there is provided a debugging device of a fast application, applied to a running side device running with the fast application, the device comprising: the device comprises a sending module, a receiving module, an acquisition module and a determination module;
the sending module is configured to report the debugging result of the target page when the target page of the fast application is operated;
the receiving module is configured to receive a repackaged compiling file package which is updated according to the debugging result;
the acquisition module is configured to acquire a path of the target page;
and the determining module is configured to determine a script file acquired from the repackaged compiled file package according to the path of the target page, wherein the script file is used for running and displaying the target page.
According to one aspect of the present disclosure, there is provided a debugging apparatus for a fast application, applied to a compiling side device, the apparatus including: the device comprises a receiving module, a generating module and a sending module;
the receiving module is configured to receive a debugging result of a target page of the fast application;
the generation module is configured to generate a repackaged compiled file package, wherein the repackaged compiled file package comprises a configuration file, and the configuration file comprises a path of a target page;
and the sending module is configured to send the repackaged compiled file package to the running side device running the fast application.
In another aspect, a computer device is provided that includes a processor and a memory having stored therein at least one instruction, at least one program, a set of codes, or a set of instructions that are loaded and executed by the processor to implement a debugging method for a fast application as provided in embodiments of the present disclosure described above.
In another aspect, a computer readable storage medium is provided, in which at least one instruction, at least one program, a set of codes, or a set of instructions is stored, the at least one instruction, the at least one program, the set of codes, or the set of instructions being loaded and executed by the processor to implement a debugging method of a fast application as provided in the embodiments of the disclosure described above.
In another aspect, a computer program product is provided which, when run on a computer, causes the computer to perform a debugging method of a quick application as provided in the embodiments of the present disclosure described above.
The technical scheme provided by the embodiment of the disclosure has the beneficial effects that at least:
when the fast application is debugged, after receiving the repackaged compiled file package, the target page is directly operated and displayed in the operation side equipment by acquiring the path of the target page, and other pages which are relied on before the target page is not required to be operated again, so that the debugging efficiency is improved.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present disclosure, the drawings required for the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present disclosure, and other drawings may be obtained according to these drawings without inventive effort for a person of ordinary skill in the art.
FIG. 1 is a schematic illustration of an implementation environment provided by an exemplary embodiment of the present disclosure;
FIG. 2 is a block diagram of an apparatus provided by an exemplary embodiment of the present disclosure;
FIG. 3 is a flowchart of a method of debugging a quick application provided by an exemplary embodiment of the present disclosure;
FIG. 4 is a schematic diagram of a target page for opening a quick application provided by an exemplary embodiment of the present disclosure;
FIG. 5 is a flowchart of a method of debugging a quick application provided by an exemplary embodiment of the present disclosure;
FIG. 6 is a flowchart of a method of debugging a quick application provided by an exemplary embodiment of the present disclosure;
FIG. 7 is a flowchart of a method of debugging a quick application provided by an exemplary embodiment of the present disclosure;
FIG. 8 is a flowchart of a method of debugging a quick application provided by an exemplary embodiment of the present disclosure;
FIG. 9 is a flowchart of a method of debugging a quick application provided by an exemplary embodiment of the present disclosure;
FIG. 10 is a block diagram of a debugging apparatus for a fast application provided by an exemplary embodiment of the present disclosure;
FIG. 11 is a block diagram of a debugging apparatus for a fast application provided by an exemplary embodiment of the present disclosure;
fig. 12 is a block diagram of a server provided by an exemplary embodiment of the present disclosure.
Detailed Description
For the purposes of clarity, technical solutions and advantages of the present disclosure, the following further details the embodiments of the present disclosure with reference to the accompanying drawings.
Fig. 1 illustrates a schematic diagram of an implementation environment of a debugging method of a quick application provided in an exemplary embodiment of the present disclosure, where the implementation environment includes a developer 100, a compiling side device 110, and a running side device 120.
The compiling side device 110 and the running side device 120 establish a debug connection.
The compiling side device 110 has a development environment for developing the quick application, and a software tool for developing the quick application is installed. The development code runs on a software tool that develops the quick application, generating a compiled package of files. Alternatively, the compiling side device 110 is a computer.
The runtime device 120 is an electronic device that installs a quick application. The runtime device 120 may be an electronic device that may be installed with a quick application, such as a smart phone, tablet, electronic book, portable personal computer, etc.
In this environment, the compiling side device 110 receives a compiling instruction input by the developer 100. The compiling side device 110 and the running side device 120 establish a debug connection. After the compiling side device 110 generates a compiling file package (e.g., rpk package), it is sent to the running side device 120 to run.
Referring in conjunction with fig. 2, fig. 2 shows a block diagram of a device 210 (a compile-side device or a run-side device) provided by an exemplary embodiment of the present disclosure. The device 210 in the present disclosure may include one or more of the following components: a processor 2110, a memory 2120, and a screen 2130.
The processor 2110 may include one or more processing cores. The processor 2110 uses various interfaces and lines to connect various portions of the overall device 210, perform various functions of the device 210, and process data by executing or executing instructions, programs, code sets, or instruction sets stored in the memory 220, and invoking data stored in the memory 2120. Alternatively, the processor 2110 may be implemented in at least one hardware form of digital signal processing (Digital Signal Processing, DSP), field programmable gate array (Field-Programmable Gate Array, FPGA), programmable logic array (Programmable Logic Array, PLA). The processor 1110 may integrate one or a combination of several of a central processing unit (Central Processing Unit, CPU), an image processor (Graphics Processing Unit, GPU), and a modem, etc. The CPU mainly processes an operating system, a user interface, an application program and the like; the GPU is used for rendering and drawing the content required to be displayed by the screen 2130; the modem is used to handle wireless communications. It will be appreciated that the modem may not be integrated into the processor 2110 and may be implemented solely by a single communication chip.
The Memory 2120 may include a random access Memory (Random Access Memory, RAM) or a Read-Only Memory (ROM). Optionally, the memory 2120 includes a non-transitory computer-readable medium (non-transitory computer-readable storage medium). Memory 2120 may be used to store instructions, programs, code, sets of codes, or sets of instructions. The memory 2120 may include a stored program area and a stored data area, wherein the stored program area may store instructions for implementing an operating system, which may be an Android (Android) system (including a system developed based on an Android system), an IOS system developed by apple corporation (including a system developed based on an IOS system depth), or other systems, instructions for implementing at least one function (such as a touch function, a sound playing function, an image playing function, etc.), instructions for implementing the various method embodiments described above, and the like. The storage data area may also store data created by the device 210 in use (e.g., phonebook, audiovisual data, chat log data), and the like.
Screen 2130 may be a touch display screen that is typically disposed on the front panel of device 210. The touch display screen may be designed as a full screen, a curved screen, or a contoured screen. The touch display screen may also be designed as a combination of a full screen and a curved screen, a combination of a shaped screen and a curved screen, and the embodiments of the present disclosure are not limited thereto.
In addition, those skilled in the art will appreciate that the configuration of the device 210 illustrated in the above figures does not constitute a limitation of the device 210, and the device 210 may include more or less components than illustrated, or may combine certain components, or may be arranged in different components. For example, the device 210 further includes a radio frequency circuit, a shooting component, a sensor, an audio circuit, a wireless fidelity (Wireless Fidelity, wiFi) component, a power supply, a bluetooth component, and the like, which are not described herein.
Fig. 3 shows a flowchart of a method for debugging a fast application provided in an exemplary embodiment of the present disclosure, where the method is applied to a running side device running the fast application, and the method includes:
step 301, when a target page of a fast application is run, reporting a debugging result of the target page;
the fast application is an installation-free application that is developed using front-end technology and rendered in a native environment. The fast application corresponds to a plurality of pages.
Optionally, the target page is other pages of the fast application than the first page. The page appearing when the quick application is opened is the top page, and the target page is other pages except the top page.
As shown in fig. 4, when a quick application is opened in the running-side device, the first page of the quick application appears. Page A depends on the top page, i.e., triggering an operation to open other pages at the top page opens page A. Page B depends on page A, i.e., triggering an operation to open other pages at page A opens page A. Before the target interface of the fast application is run, the running side device needs to run gradually other pages that were previously relied upon.
Debugging refers to the process of debugging the display effect of the page of the fast application on the running side equipment so as to determine whether the page can be normally displayed. And through debugging, the running side equipment reports a debugging result.
In the debugging process, each time a page is executed, the running side device reports the debugging result corresponding to the page to the compiling side device. The developer can determine the debugging result of the current page of the fast application running on the compiling side device.
Optionally, the debug result corresponds to a target page, and the debug result includes: page running results and debugging information.
Optionally, the page running result includes: rendering style, page data calculation.
If the developer determines that the display of the target page currently operated by the quick application is problematic on the compiling side device, the developer modifies the code of the target page.
Step 302, receiving a repackaged compiled file package, wherein the repackaged compiled file package is updated according to a debugging result;
optionally, the compiling file package is a software package sent by a compiling side device and received by an operating side device.
Optionally, the developer inputs the written code in a compiling side device, and the compiling side device compiles the code to generate a compiling file package.
The running side equipment reports the debugging result of the target page, a developer modifies and stores codes according to the debugging result, and the compiling side equipment automatically compiles the updated codes and repackages the compiling file package.
Step 303, obtaining a path of a target page;
optionally, the path is a JS file path. Each page of the fast application corresponds to a JS file path.
The JS file refers to a text document containing JavaScript code lines and is used for executing JavaScript instructions in a webpage.
Illustratively, the target page is Page X, and the target page's path is "/X/index. Js"; the target page is page A, and the path of the target page is "/a/index. Js".
Step 304, determining a script file obtained from the repackaged compiled file package according to the path of the target page, wherein the script file is used for running and displaying the target page.
A Script (Script) file is a text file provided to a runtime-side device for execution. The script file may be created by a text editor.
Optionally, the script file is a JS file.
And the running side equipment acquires a script file corresponding to the target page from the repackaged compiling file package according to the acquired path of the target page, recreates a new page, namely the target interface, executes the script file, acquires a cascading style sheet (Cascading Style Sheets, CSS) file associated with the script file, and therefore renders the target page.
In summary, in the method provided by the embodiment, when the fast application is debugged, after receiving the repackaged compiled file packet, the target page is directly operated and displayed in the operation side device by acquiring the path of the target page, so that other pages depending on before the target page is not required to be operated again, and the debugging efficiency is improved.
In an alternative embodiment based on fig. 3, fig. 5 shows a debugging method of a fast application provided in an exemplary embodiment of the present disclosure, which is applied to a running side device running the fast application. In the present embodiment, step 303 is instead implemented as step 3031, or step 3032, or step 3033:
step 3031, when the fast application is in a hot loading debugging mode, acquiring a path of a target page;
the hot-load modulation mode (developer mode) refers to a debug mode that reloads the development environment at runtime instead of the entire hot application.
Alternatively, the class file (i.e., the development environment) is reloaded by the hot load at runtime, by starting a background thread, detecting the change in the timestamp of the class file at regular time, and reloading the class if the timestamp of the class changes.
The fast application is in the hot load debugging mode, so that the debugging time can be saved. And by determining that the fast application is in the hot loading debugging mode and executing the subsequent steps, the debugging efficiency is improved.
Step 3032, when the running side device is running a compiled file package with the same package name as the repackaged compiled file package, acquiring a path of the target page;
by confirming that the running side device is running the compiled file package with the same package name as the repackaged compiled file package, the repackaged compiled file package to be run is determined to be the fast application which the developer wants to debug again, and the situation of debugging object errors is avoided.
Step 3033, when the fast application is in the hot load debug mode and the running side device is running a compiled file package with the same package name as the repackaged compiled file package, acquiring a path of the target page;
and by determining that the fast application is in the hot loading debugging mode and executing the subsequent steps, the debugging efficiency is improved.
By confirming that the running side device is running the compiled file package with the same package name as the repackaged compiled file package, the repackaged compiled file package to be run is determined to be the fast application which the developer wants to debug again, and the situation of debugging object errors is avoided.
In one example, obtaining a path of a target page includes: acquiring the identification of a target page from the self-running code in the repackaged compiled file package; acquiring a configuration file in the repackaged compiled file package, determining a path of the target page in the configuration file according to the identifier of the target page, wherein the configuration file contains the corresponding relationship between the identifier of the target page and the path of the target page; or directly acquiring the path of the target page from the self-running code in the repackaged compiled file package.
In one possible implementation, the running side device obtains the identification of the target page from the self-running code in the repackaged compiled file package; and acquiring a configuration file in the repackaged compiled file package, determining a path of the target page in the configuration file according to the identification of the target page, wherein the configuration file contains the corresponding relationship between the identification of the target page and the path of the target page.
Alternatively, the self-running code is a code that is automatically run by the running side device when the repackaged compiled package is started to run. The self-running code contains the identification of the target page.
The identification of the target page corresponds to the target page. And the running side equipment acquires the identification of the target page by running the self-running code, and determines the target page which needs to be jumped and displayed by the quick application.
Illustratively, the target page is page X, with the target page identified as X. The running side equipment acquires X from the self-running code, and determines that the target page needing to be skipped and displayed is page X.
The configuration file is a file containing configuration information of the quick application in a repackaged compiled package of files. The configuration information comprises relevant information of the identification of the target page and the path corresponding relation of the target page.
Optionally, the configuration file is a json format file.
Illustratively, the configuration file is in the format of "a: /path/a.ux ", where" a "is the identity of the target page. After the repackaged compiled file package is analyzed by the operation side device, the identifier 'a' of the target page is obtained through reading the self-operation code, the configuration file comprises the identifier of the target page and the path corresponding relation of the target page, the path of the target page indicated by the identifier 'a' of the target page is determined to be 'path/a.ux' through reading the configuration file, and the script file of the target page is obtained according to the path of the target page, so that a new page is recreated, and the page is jumped to the target page.
In another possible implementation, the runtime device directly obtains the path of the target page from the self-running code in the repackaged compiled bundle.
Illustratively, the path of the target page is directly stored in the self-running code of the repackaged compiled file package, and the run-side device directly reads the path "/path/a.ux" of the target page. And acquiring the script file of the target page according to the path of the target page, thereby recreating a new page and enabling the page to jump to the target page.
And the running side equipment acquires script files corresponding to the target pages from the repackaged compiled file package according to the acquired paths of the target pages, and recreates new pages, namely target interfaces.
In summary, in the method provided by the embodiment, when the fast application is debugged, after receiving the repackaged compiled file packet, the target page is directly operated and displayed in the operation side device by acquiring the path of the target page, so that other pages depending on before the target page is not required to be operated again, and the debugging efficiency is improved.
And by determining that the fast application is in the hot loading debugging mode and executing the subsequent steps, the debugging efficiency is improved. By confirming that the running side device is running the compiled file package with the same package name as the repackaged compiled file package, the repackaged compiled file package to be run is determined to be the fast application which the developer wants to debug again, and the situation of debugging object errors is avoided.
In an alternative embodiment based on fig. 3, fig. 6 shows a debugging method of a fast application provided in an exemplary embodiment of the present disclosure, which is applied to a running side device running the fast application. In this embodiment, the method further comprises step 305:
And step 305, reporting the debugging result of the target page again.
Optionally, the target page is other pages of the fast application than the first page.
Optionally, the debug result corresponds to a target page, and the debug result includes: page running results and debugging information.
Optionally, the page running result includes: rendering style, page data calculation.
And the running side equipment determines a script file obtained from the repackaged compiling file package according to the path of the target page, and after running and displaying the target page through the script file, the running side equipment reports the debugging result of the target interface to the compiling side equipment again.
It should be noted that, if the developer finds that the problem of the target page is not solved or finds a new problem of the target page according to the debug result of the target page reported again by the running side device, and further modifies the code of the target page again, at this time, steps 302 to 305 in the embodiment need to be repeated to debug the target page again.
In summary, in the method provided by the embodiment, when the fast application is debugged, after receiving the repackaged compiled file packet, the target page is directly operated and displayed in the operation side device by acquiring the path of the target page, so that other pages depending on before the target page is not required to be operated again, and the debugging efficiency is improved.
And confirming the debugging effect of the target page by reporting the debugging result of the target page again.
Fig. 7 shows a flowchart of a method for debugging a quick application provided in an exemplary embodiment of the present disclosure, which is applied to a compiling side device, and the method includes:
step 701, receiving a debugging result of a target page of a fast application;
the fast application is an installation-free application that is developed using front-end technology and rendered in a native environment. The fast application corresponds to a plurality of pages.
Optionally, the target page is other pages of the fast application than the first page. The page appearing when the quick application is opened is the top page, and the target page is other pages except the top page.
And the debugging result of the target page is sent to the compiling side device from the running side device running the fast application. And the developer determines the page display condition of the target page through the debugging result.
Step 702, generating a repackaged compiled file package, wherein the repackaged compiled file package comprises a path of a target page;
in one example, generating a repackaged compiled bundle that includes a path of a target page includes: generating a repackaged compiled file package, wherein the self-running code in the repackaged compiled file package contains a path of a target page; or generating a repackaged compiling file package, wherein the self-running code in the repackaged compiling file package contains the identification of the target page, and the configuration file in the repackaged compiling file package contains the corresponding relation between the identification of the target page and the path of the target page.
In one possible implementation manner, the compiling side device generates a repackaged compiling file package, the self-running code in the repackaged compiling file package contains the identification of the target page, and the configuration file in the repackaged compiling file package contains the corresponding relation between the identification of the target page and the path of the target page.
Alternatively, the self-running code is a code that is automatically run by the running side device when the repackaged compiled package is started to run. The self-running code contains the identification of the target page. The identification of the target page corresponds to the target page.
Illustratively, the target page is page X, with the target page identified as X. The compiling side device generates a repackaged compiling file package, wherein the self-running code contains X, and the target page needing to be jumped and displayed can be determined to be page X through X.
The configuration file is a file containing configuration information of the quick application in a repackaged compiled package of files. The configuration information comprises relevant information of the identification of the target page and the path corresponding relation of the target page.
Optionally, the configuration file is a json format file.
Illustratively, the configuration file is in the format of "a: /path/a.ux ", where" a "is the identity of the target page. The path of the target page referred to by the identification "a" of the target page is determined to be "/path/a. Ux" through the configuration file.
In another possible implementation, the compiling side device generates a repackaged compiling package, the self-running code in the repackaged compiling package containing the path of the target page.
Illustratively, the path of the target page is stored directly in the self-running code of the repackaged compiled file package, the target page including the path "/path/a. Ux" of the target page.
Step 703, sending the repackaged compiled file package to an operation side device running the fast application;
optionally, the compiling file package is a software package sent by a compiling side device and received by an operating side device.
After the running side device reports the debugging result of the target page, a developer modifies and stores the code according to the debugging result, and the compiling side device automatically compiles the updated code, repackages the compiling file package and sends the compiling file package to the running side device running the fast application.
In summary, according to the method provided by the embodiment, when the compiling side device generates the repackaged compiling file package, the running side device directly runs and displays the target page according to the path of the target page by including the path of the target page in the compiling file package, and other pages which are relied on before the target page is required to be run again, so that the debugging efficiency is improved.
In an alternative embodiment based on fig. 7, fig. 8 shows a method for debugging a fast application provided in an exemplary embodiment of the present disclosure, which is applied to a compiling side device. In this embodiment, the step 702 may be alternatively implemented as the step 7021 and the step 7022:
step 7021, listening for codes of a fast application;
alternatively, the code of the fast application is listened to by launching a hypertext transfer protocol (Hyper Text Transfer Protocol, HTTP) service at the compiling side device.
Illustratively, creating an HTTP Listener (HTTP Listener) enables the HTTP service to listen to the code of the fast application.
Optionally, the HTTP service is started by default at the compiling side, or a starting operation from a developer is received, and the HTTP service is started. If the code of the quick application is changed, the compiling side does not need to receive a compiling instruction from a developer, and the changed code is automatically generated into a repackaged compiling file package.
Step 7022, the step of generating a repackaged compiled bundle is performed if the code of the target page of the fast application changes.
Optionally, the code of the fast application is listened to through the HTTP service.
And the developer modifies and stores the codes according to the debugging result, the compiling side device monitors the change of the codes of the quick application through the HTTP service, the compiling side device automatically compiles the updated codes, repackages the compiling file package and sends the compiling file package to the running side device running the quick application.
In one example, the debug results for the target page are again received.
Optionally, the debug result corresponds to a target page, and the debug result includes: page running results and debugging information.
Optionally, the page running result includes: rendering style, page data calculation.
The running side device determines a script file obtained from the repackaged compiling file package according to the path of the target page, and after the target page is run and displayed through the script file, the running side device reports the debugging result of the target interface to the compiling side device again, and the compiling side device receives the debugging result of the target page again.
It should be noted that, if the developer finds that the problem of the target page is not solved or finds a new problem of the target page according to the debug result of the target page reported by the running side device, and further modifies the code of the target page again, at this time, steps 7021 to 7022 in the embodiment need to be repeated to debug the target page again.
In summary, according to the method provided by the embodiment, when the compiling side device generates the repackaged compiling file package, the running side device directly runs and displays the target page according to the path of the target page by including the path of the target page in the compiling file package, so that other pages which are relied on before the target page is not required to be run again, and the debugging efficiency is improved.
By monitoring the code of the fast application, the compiling side device automatically generates a repackaged compiling file package according to the changed code of the fast application without receiving a compiling instruction of a developer, so that the compiling efficiency is improved, and the efficiency of the whole debugging process is further improved.
Referring in conjunction with fig. 9, fig. 9 shows a flowchart of a method for debugging a quick application provided by an exemplary embodiment of the present disclosure, the method includes:
step 901, a compiling side device and an operating side device establish debugging connection;
by establishing the debug connection, the compiling side device can send the compiled file package to the running side device in which the quick application is installed.
Step 902, the running side device runs to a target page of the quick application;
the fast application is an installation-free application that is developed using front-end technology and rendered in a native environment. The fast application corresponds to a plurality of pages.
Optionally, the target page is other pages of the fast application than the first page. The page appearing when the quick application is opened is the top page, and the target page is other pages except the top page.
Step 903, the running side device reports the debugging result of the target page to the compiling side device;
in the debugging process, each time a page is executed, the running side device reports the debugging result corresponding to the page to the compiling side device. The developer can determine the debugging result of the current page of the fast application running on the compiling side device.
Step 904, the compiling side equipment monitors that the code of the fast application is changed, and a repackaged compiling file package is generated;
alternatively, the code of the fast application is monitored by starting the HTTP service at the compiling side device.
Step 905, the compiling side device sends a notification of updating the compiling file package to the running side device;
after the compiling side device generates the repackaged compiling file package, the compiling side device sends a notice for updating the compiling file package to the running side device, so that the running side device pulls the repackaged compiling file package at the compiling side device.
Step 906, the compiling side device sends the repackaged compiling file package to the running side device;
step 907, when the fast application is in the hot-loading modulation mode and the running side device is running a compiled file package with the same package name as the repackaged compiled file package, obtaining a path of the target page;
optionally, acquiring the path of the target page includes: acquiring the identification of a target page from the self-running code in the repackaged compiled file package; acquiring a configuration file in the repackaged compiled file package, determining a path of the target page in the configuration file according to the identifier of the target page, wherein the configuration file contains the corresponding relationship between the identifier of the target page and the path of the target page; or directly acquiring the path of the target page from the self-running code in the repackaged compiled file package.
Step 908, the running side device determines, according to the path of the target page, a script file obtained from the repackaged compiled file package;
the script file is a text file provided to the runtime device for execution. The script file may be created by a text editor.
And the running side equipment acquires a script file corresponding to the target page from the repackaged compiling file package according to the acquired path of the target page, recreates a new page, namely the target interface, executes the script file, acquires a CSS file associated with the script file, and therefore renders the target page.
Step 909, the running side device reports the debugging result of the target page to the compiling side device again;
it should be noted that, if the developer finds that the problem of the target page is not solved or finds a new problem of the target page according to the debug result of the target page reported again by the running side device, and further modifies the code of the target page again, at this time, steps 904 to 909 in the embodiment need to be repeated to debug the target page again.
Fig. 10 is a block diagram of a debugging apparatus for a fast application according to an exemplary embodiment of the present disclosure, which is applied to a running side device running a fast application, and includes: a transmitting module 1001, a receiving module 1002, an acquiring module 1003, and a determining module 1004;
The sending module 1001 is configured to report a debugging result of a target page when the target page of the fast application is run;
a receiving module 1002 configured to receive a repackaged compiled document package, the repackaged compiled document package being updated according to a debugging result;
an acquisition module 1003 configured to acquire a path of a target page;
the determining module 1004 is configured to determine, according to the path of the target page, a script file obtained from the repackaged compiled file package, where the script file is used to run and display the target page.
In one example, an acquisition module 1003 configured to acquire an identification of a target page from self-running code in the repackaged compiled bundle; acquiring a configuration file in the repackaged compiled file package, determining a path of the target page in the configuration file according to the identifier of the target page, wherein the configuration file contains the corresponding relationship between the identifier of the target page and the path of the target page; or, the obtaining module 1003 is configured to directly obtain the path of the target page from the self-running code in the repackaged compiled file package.
In one example, the obtaining module 1003 is configured to perform the step of obtaining the path of the target page when the fast application is in the hot-load debug mode; or, an obtaining module 1003 configured to perform a step of obtaining a path of the target page when the running side device is running a compiled package having the same package name as the repackaged compiled package; or, the obtaining module 1003 is configured to perform the step of obtaining the path of the target page when the fast application is in the hot load debug mode and the running side device is running the compiled package having the same package name as the repackaged compiled package.
In one example, the sending module 1001 is configured to report the debug result of the target page again.
Fig. 11 shows a block diagram of a debugging apparatus for a quick application provided in an exemplary embodiment of the present disclosure, applied to a compiling side device, the apparatus including: a receiving module 1101, a generating module 1102, a transmitting module 1103, and a listening module 1104;
a receiving module 1101 configured to receive a debug result of a target page of a fast application;
a generation module 1102 configured to generate a repackaged compilation file package, the repackaged compilation file package including a configuration file, the configuration file including a path for the target page;
the sending module 1103 is configured to send the repackaged compiled file package to the running side device running the fast application.
In one example, a listening module 1104 configured to listen for code of a fast application; the generating module 1102 is configured to execute the step of generating the repackaged compiled bundle if the code of the target page of the fast application changes.
In one example, the generation module 1102 is configured to generate a repackaged compiled bundle, the self-running code in the repackaged compiled bundle containing a path of the target page; or, the generating module 1102 is configured to generate a repackaged compiled file package, where the self-running code in the repackaged compiled file package includes an identifier of the target page, and the configuration file in the repackaged compiled file package includes a path correspondence between the identifier of the target page and the target page.
In one example, the receiving module 1101 is configured to receive the debug result of the target page again.
The present disclosure also provides a server including a processor and a memory, where the memory stores at least one instruction, where the at least one instruction is loaded and executed by the processor to implement the method for debugging a fast application provided by the foregoing method embodiments. It should be noted that the server may be a server as provided in fig. 12 below.
Referring to fig. 12, a schematic diagram of a server according to an exemplary embodiment of the present disclosure is shown. Specifically, the present invention relates to a method for manufacturing a semiconductor device. The server 1200 includes a Central Processing Unit (CPU) 1201, a system memory 1204 including a Random Access Memory (RAM) 1202 and a Read Only Memory (ROM) 1203, and a system bus 1205 connecting the system memory 1204 and the central processing unit 1201. The server 1200 also includes an Input/output (I/O) system 1206, which facilitates the transfer of information between various devices within the computer, and a mass storage device 1207 for storing an operating system 1213, application programs 1214, and other program modules 1212.
The basic input/output system 1206 includes a display 1208 for displaying information and an input device 1209, such as a mouse, keyboard, etc., for user input of information. Wherein both the display 1208 and the input device 1209 are coupled to the central processing unit 1201 via an input-output controller 1210 coupled to a system bus 1205. The basic input/output system 1206 can also include an input/output controller 1210 for receiving and processing input from a number of other devices, such as a keyboard, mouse, or electronic stylus. Similarly, the input output controller 1210 also provides output to a display screen, a printer, or other type of output device.
The mass storage device 1207 is connected to the central processing unit 1201 through a mass storage controller (not shown) connected to the system bus 1205. Mass storage device 1207 and its associated computer-readable media provide non-volatile storage for server 1200. That is, mass storage device 1207 may include a computer readable medium (not shown), such as a hard disk or CD-ROI drive.
Computer readable media may include computer storage media and communication media without loss of generality. Computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes RAM, ROM, erasable programmable read-only memory (Erasable Programmable Read Only Memory, EPROM), electrically erasable programmable read-only memory (Electrically Erasable Programmable Read Only Memory, EEPROM), flash memory or other solid state memory technology, compact disc read-only memory (CD-ROM), high density Digital Video Disk (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices. Of course, those skilled in the art will recognize that computer storage media are not limited to the ones described above. The system memory 1204 and mass storage device 1207 described above may be collectively referred to as memory.
The memory stores one or more programs configured to be executed by the one or more central processing units 1201, the one or more programs containing instructions for implementing the debugging method of the quick application provided by the above-described respective method embodiments, the central processing unit 1201 executing the one or more programs to implement the debugging method of the quick application provided by the above-described respective method embodiments.
According to various embodiments of the disclosure, the server 1200 may also operate through a network, such as the Internet, to remote computers connected to the network. That is, the server 1200 may be connected to the network 1212 through a network interface unit 1211 coupled to the system bus 1205, or alternatively, the network interface unit 1211 may be used to connect to other types of networks or remote computer systems (not shown).
The memory also includes one or more programs, one or more programs stored in the memory, the one or more programs including steps executed by the server in the debugging method for performing the quick application provided by the embodiment of the present invention.
The embodiment of the disclosure also provides a computer device, which comprises a memory and a processor, wherein at least one instruction, at least one section of program, code set or instruction set is stored in the memory, and the at least one instruction, the at least one section of program, the code set or the instruction set is loaded by the processor and realizes the debugging method of the quick application.
The embodiment of the disclosure also provides a computer readable storage medium, in which at least one instruction, at least one section of program, a code set or an instruction set is stored, and the at least one instruction, the at least one section of program, the code set or the instruction set is loaded and executed by a processor to implement the debugging method of the quick application.
The present disclosure also provides a computer program product which, when run on a computer, causes the computer to perform the method for debugging a fast application provided by the above-mentioned respective method embodiments.
Those of ordinary skill in the art will appreciate that all or part of the steps in the various methods of the above embodiments may be implemented by a program for instructing related hardware, and the program may be stored in a computer readable storage medium, which may be a computer readable storage medium included in the memory of the above embodiments; or may be a computer-readable storage medium, alone, that is not incorporated into the terminal. The computer readable storage medium stores at least one instruction, at least one program, a code set, or an instruction set, and the at least one instruction, the at least one program, the code set, or the instruction set is loaded and executed by a processor to implement the fast-application debugging method.
Alternatively, the computer-readable storage medium may include: read Only Memory (ROM), random access Memory (RAM, random Access Memory), solid state disk (SSD, solid State Drives), or optical disk, etc. The random access memory may include resistive random access memory (ReRAM, resistance Random Access Memory) and dynamic random access memory (DRAM, dynamic Random Access Memory), among others. The foregoing embodiment numbers of the present disclosure are merely for description and do not represent advantages or disadvantages of the embodiments.
It will be understood by those skilled in the art that all or part of the steps for implementing the above embodiments may be implemented by hardware, or may be implemented by a program for instructing relevant hardware, and the program may be stored in a computer readable storage medium, where the storage medium may be a read-only memory, a magnetic disk or an optical disk, etc.
The foregoing is merely an alternative embodiment of the present disclosure, and is not intended to limit the present disclosure, any modification, equivalent replacement, improvement, etc. that comes within the spirit and principles of the present disclosure are included in the scope of the present disclosure.
Claims (18)
1. A method for debugging a fast application, wherein the method is applied to a device on an operation side on which the fast application is operated, the method comprising:
When running to a target page of the fast application, reporting a debugging result of the target page, wherein the target page is other pages of the fast application except a first page, and the first page is a page which appears when the fast application is opened;
receiving a repackaged compiled file package, wherein the repackaged compiled file package is updated according to the debugging result;
when the fast application is in a hot loading debugging mode and the running side device is running a compiling file package with the same package name as the repackaged compiling file package, acquiring the identification of the target page from a self-running code in the repackaged compiling file package; acquiring a configuration file in the repackaged compiled file package, determining a path of the target page in the configuration file according to the identifier of the target page, wherein the configuration file comprises a corresponding relation between the identifier of the target page and the path of the target page, and the hot loading debugging mode is a debugging mode for reloading a development environment in running, wherein the hot loading debugging mode reloads a class file in running, and the class file is reloaded when the timestamp of the class file changes by starting a background thread;
And determining a script file acquired from the repackaged compiled file package according to the path of the target page, wherein the script file is used for running and displaying the target page.
2. The method according to claim 1, wherein the method further comprises:
and directly acquiring the path of the target page from the self-running code in the repackaged compiled file package.
3. The method according to claim 1, wherein the method further comprises:
executing the step of acquiring the path of the target page when the fast application is in the hot load debugging mode;
or alternatively, the first and second heat exchangers may be,
and when the running side equipment is running the compiled file package with the same package name as the repackaged compiled file package, executing the step of acquiring the path of the target page.
4. A method according to any one of claims 1 to 3, wherein the method further comprises:
and reporting the debugging result of the target page again.
5. A method for debugging a fast application, the method being applied to a compiling side device, the method comprising:
receiving a debugging result of a target page of the fast application, wherein the target page is other pages of the fast application except a first page, and the first page is a page which appears when the fast application is opened;
Generating a repackaged compiling file package, wherein the repackaged compiling file package is updated according to the debugging result, self-running codes in the repackaged compiling file package contain the identification of the target page, and configuration files in the repackaged compiling file package contain the identification of the target page and the path corresponding relation of the target page;
transmitting the repackaged compiled file package to a running side device running the fast application, wherein when the fast application is in a hot loading debugging mode and the running side device is running the compiled file package with the same package name as the repackaged compiled file package, the running side device obtains the identification of the target page from self-running codes in the repackaged compiled file package; the running side equipment acquires a configuration file in the repackaged compiled file package, a path of the target page is determined in the configuration file according to the identification of the target page, the hot loading debugging mode refers to a debugging mode of reloading a development environment in running, the hot loading debugging mode reloads a class file in running, a background thread is started, time stamp change of the class file is detected regularly, and the class file is reloaded when the time stamp of the class file is changed.
6. The method of claim 5, wherein the method further comprises:
monitoring codes of the fast application;
and if the code of the target page of the quick application is changed, executing the step of generating a repackaged compiled file package.
7. The method of claim 5, wherein the method further comprises:
generating a repackaged compiled file package, wherein the self-running code in the repackaged compiled file package comprises the path of the target page.
8. The method according to any one of claims 5 to 7, further comprising:
and receiving the debugging result of the target page again.
9. A debugging device for a fast application, wherein the debugging device is applied to a running side device running the fast application, and the device comprises: the device comprises a sending module, a receiving module, an acquisition module and a determination module;
the sending module is configured to report a debugging result of a target page of the fast application when the fast application is run to the target page, wherein the target page is other pages of the fast application except a first page, and the first page is a page which appears when the fast application is opened;
The receiving module is configured to receive a repackaged compiled file package, and the repackaged compiled file package is updated according to the debugging result;
the acquisition module is configured to acquire the identification of the target page from the self-running code in the repackaged compiled file package when the quick application is in a hot loading debugging mode and the running side device is running the compiled file package with the same package name as the repackaged compiled file package; acquiring a configuration file in the repackaged compiled file package, determining a path of the target page in the configuration file according to the identifier of the target page, wherein the configuration file comprises a corresponding relation between the identifier of the target page and the path of the target page, and the hot loading debugging mode is a debugging mode for reloading a development environment in running, wherein the hot loading debugging mode reloads a class file in running, and the class file is reloaded when the timestamp of the class file changes by starting a background thread;
the determining module is configured to determine a script file acquired from the repackaged compiled file package according to the path of the target page, wherein the script file is used for running and displaying the target page.
10. The apparatus of claim 9, wherein the device comprises a plurality of sensors,
the acquisition module is configured to directly acquire the path of the target page from the self-running code in the repackaged compiled file package.
11. The apparatus of claim 10, wherein the device comprises a plurality of sensors,
the acquisition module is configured to execute the step of acquiring the path of the target page when the fast application is in the hot-loading debugging mode;
or alternatively, the first and second heat exchangers may be,
the obtaining module is configured to execute the step of obtaining the path of the target page when the running side device is running a compiled file package with the same package name as the repackaged compiled file package.
12. The device according to any one of claims 9 to 11, wherein,
the sending module is configured to report the debugging result of the target page again.
13. A debugging device for a fast application, the device being applied to a compiling side device, the device comprising: the device comprises a receiving module, a generating module and a sending module;
the receiving module is configured to receive a debugging result of a target page of the fast application, wherein the target page is other pages of the fast application except a first page, and the first page refers to a page which appears when the fast application is opened;
The generation module is configured to generate a repackaged compiled file package, the repackaged compiled file package is updated according to the debugging result, self-running codes in the repackaged compiled file package contain the identification of the target page, and configuration files in the repackaged compiled file package contain the corresponding relation between the identification of the target page and the path of the target page;
the sending module is configured to send the repackaged compiled file package to an operation side device running the fast application, wherein when the fast application is in a hot loading debugging mode and the operation side device is running a compiled file package with the same package name as the repackaged compiled file package, the operation side device obtains the identification of the target page from self-running codes in the repackaged compiled file package; the running side equipment acquires a configuration file in the repackaged compiled file package, a path of the target page is determined in the configuration file according to the identification of the target page, the hot loading debugging mode refers to a debugging mode of reloading a development environment in running, the hot loading debugging mode reloads a class file in running, a background thread is started, time stamp change of the class file is detected regularly, and the class file is reloaded when the time stamp of the class file is changed.
14. The apparatus of claim 13, wherein the apparatus further comprises a listening module;
the monitoring module is configured to monitor codes of the fast application;
the generation module is configured to execute the step of generating a repackaged compiled file package if the code of the target page of the quick application changes.
15. The apparatus of claim 13, wherein the device comprises a plurality of sensors,
the generation module is configured to generate a repackaged compiled bundle of files, the self-running code in the repackaged compiled bundle of files containing a path of the target page.
16. The device according to any one of claims 13 to 15, wherein,
the receiving module is configured to receive the debugging result of the target page again.
17. A computer device comprising a processor and a memory, wherein the memory has stored therein at least one instruction, at least one program, code set, or instruction set that is loaded and executed by the processor to implement the method of debugging a fast application according to any one of claims 1 to 8.
18. A computer readable storage medium having stored therein at least one instruction, at least one program, code set, or instruction set that is loaded and executed by a processor to implement the method of debugging a fast application according to any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911040405.7A CN110795353B (en) | 2019-10-29 | 2019-10-29 | Quick application debugging method, device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911040405.7A CN110795353B (en) | 2019-10-29 | 2019-10-29 | Quick application debugging method, device, equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110795353A CN110795353A (en) | 2020-02-14 |
| CN110795353B true CN110795353B (en) | 2023-10-13 |
Family
ID=69441894
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911040405.7A Active CN110795353B (en) | 2019-10-29 | 2019-10-29 | Quick application debugging method, device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110795353B (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111338961B (en) * | 2020-02-28 | 2023-10-20 | 北京小米移动软件有限公司 | Application debugging method and device, electronic equipment and storage medium |
| CN115039069A (en) * | 2020-03-06 | 2022-09-09 | 深圳市欢太科技有限公司 | Application processing method and related device |
| CN115407977A (en) * | 2021-05-28 | 2022-11-29 | 腾讯科技（深圳）有限公司 | Information compiling method, device, equipment and computer readable storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102508875A (en) * | 2011-10-18 | 2012-06-20 | 深圳市共进电子股份有限公司 | Method for quickly modifying and expanding WEB user interface of terminal equipment |
| CN109032917A (en) * | 2017-06-09 | 2018-12-18 | 北京金山云网络技术有限公司 | Page adjustment method and system, mobile terminal and computer end |
| CN109542463A (en) * | 2018-10-26 | 2019-03-29 | 深圳壹账通智能科技有限公司 | Compiling file packet transmission method, device, computer equipment and storage medium |
-
2019
- 2019-10-29 CN CN201911040405.7A patent/CN110795353B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102508875A (en) * | 2011-10-18 | 2012-06-20 | 深圳市共进电子股份有限公司 | Method for quickly modifying and expanding WEB user interface of terminal equipment |
| CN109032917A (en) * | 2017-06-09 | 2018-12-18 | 北京金山云网络技术有限公司 | Page adjustment method and system, mobile terminal and computer end |
| CN109542463A (en) * | 2018-10-26 | 2019-03-29 | 深圳壹账通智能科技有限公司 | Compiling file packet transmission method, device, computer equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110795353A (en) | 2020-02-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110795353B (en) | Quick application debugging method, device, equipment and storage medium | |
| CN106598835B (en) | Application testing method, device and system | |
| CN111026645B (en) | User interface automatic test method and device, storage medium and electronic equipment | |
| CN108255701B (en) | Scene testing method and mobile terminal | |
| CN115065652B (en) | Message reply method and device, storage medium and computer equipment | |
| CN110297776B (en) | Detection report generation and reception methods, devices, equipment and storage medium | |
| CN110647471A (en) | Interface test case generation method, electronic device and storage medium | |
| CN112463634A (en) | Software testing method and device under micro-service architecture | |
| CN114036439A (en) | Website building method, device, medium and electronic equipment | |
| CN111444453A (en) | Page return data processing method and device | |
| US10432490B2 (en) | Monitoring single content page application transitions | |
| CN112463519A (en) | Flatter-based page use behavior data non-buried point statistical method, equipment and storage medium | |
| CN108170605A (en) | Submission method, client and the computer readable storage medium of bug information | |
| CN112764796A (en) | Installation package generation system | |
| CN112463574A (en) | Software testing method, device, system, equipment and storage medium | |
| CN111435328A (en) | Application testing method and device, electronic equipment and readable storage medium | |
| CN108614704B (en) | Code compiling method and device | |
| CN114546850A (en) | Automatic testing method, system and device for embedded point and storage medium | |
| CN112799927A (en) | Operation behavior information acquisition method and device for front-end user | |
| CN111026651B (en) | Test method, device, storage medium and electronic equipment | |
| US10530835B2 (en) | Application recording | |
| CN114371866A (en) | Version reconfiguration test method, device and equipment of service system | |
| CN112965896A (en) | Test environment fault detection method and device based on dynamic byte codes | |
| CN116610557B (en) | Action binding information debugging method and device, storage medium and electronic equipment | |
| CN110647331A (en) | Development tool acquisition method and device, storage medium and electronic equipment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |