CN113641580B - Mixed mode mobile application debugging method and system - Google Patents
Mixed mode mobile application debugging method and system Download PDFInfo
- Publication number
- CN113641580B CN113641580B CN202110919363.5A CN202110919363A CN113641580B CN 113641580 B CN113641580 B CN 113641580B CN 202110919363 A CN202110919363 A CN 202110919363A CN 113641580 B CN113641580 B CN 113641580B
- Authority
- CN
- China
- Prior art keywords
- client
- page
- websocket
- mobile application
- debugging
- 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/3628—Software debugging of optimised code
-
- 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/3664—Environments for testing or debugging software
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
Abstract
The embodiment of the application provides a mixed mode mobile application debugging system, which comprises the following steps: the electronic desktop client is used for creating a local project packaging service, a WebSocket client and a first module hot replacement client, and establishing WebSocket long connection with the node server through the WebSocket client; the local project packaging service is used for adding a first script for creating a second module hot-replacement client side and a creation module hot-replacement server side into the page codes, and packaging the page codes containing the first script to generate a page code file catalog; the electronic desktop client is used for packing the page code file catalogue to generate a page code file package, uploading the page code file package to the node server so that the node server decompresses the page code file package to generate a first code file, and deploying the generated first code file into the static resource service; and the mixed mode mobile application is used for acquiring and loading the first code file from the static resource service so as to open the page to be debugged.
Description
Technical Field
The embodiment of the application relates to the technical field of computers, in particular to a method and a system for debugging a mixed mode mobile application.
Background
Hybrid applications have evolved from the need for updates and markets for computer application technology. Hybrid applications are mixed-mode mobile applications that are interposed between Native applications (Native apps) and Web applications (Web apps). After the Hybrid application is developed, remote debugging of the Hybrid application is required in order to find problems in the development process. However, the inventor found that when performing hot update on the Hybrid application, for the Hybrid item (non-Vue framework class) on the real machine constructed based on weback, the page built-in HMR WebSocket Client would be connected to 127.0.0.1 back source address by default, even if the address is changed to the IP address of the local PC by modifying the weback configuration (custom practice of the Vue framework), the real machine network needs to be proxied to the local PC by using a Charles agent tool, etc., and the hot update channel can only establish a WebSocket long connection channel between the real machine and the WebSocket server of the local PC development project for hot update. However, when the Charles agent is configured, the configuration is complicated, so that the cost for the user is high.
Disclosure of Invention
The embodiment of the application aims to provide a mixed mode mobile application debugging system so as to solve the problem that the configuration is complicated in the configuration process when a Charles agent tool is used for hot update, so that the use cost of a user is high.
An aspect of the embodiment of the application provides a mixed mode mobile application debugging system, which comprises a debugging device, a node server and a device to be debugged, wherein the device to be debugged is provided with a mixed mode mobile application to be debugged, and an Electron desktop client and a local project debugging service are arranged in the debugging device, wherein:
the Electron desktop client is used for creating a local project packaging service, a WebSocket client and a first module hot replacement client, and is used for establishing a first WebSocket long connection with the node server through the WebSocket client;
the electronic desktop client is further used for adding a first script for creating a second module hot-replacement client in the page code of the mixed-mode mobile application through the local project packaging service;
the local project debugging service is used for creating a module hot replacement server and packaging page codes containing the first script to generate a page code file directory;
The Electron desktop client is further configured to package the page code file directory to generate a page code file package, and upload the page code file package to the node server;
the node server is used for decompressing the page code file package to generate a first code file, and deploying the generated first code file into the static resource service;
the mixed mode mobile application is used for acquiring and loading the first code file from the static resource service so as to open the page to be debugged;
the mixed mode mobile application is further configured to create a second module hot-swap client according to a first script in the first code file, and establish a second WebSocket long connection with the node server through the second module hot-swap client;
the node server is further configured to notify, after the second WebSocket long connection is established, the electronic desktop client to establish a third WebSocket long connection between the first module hot-replacement client and the module hot-replacement server through the first WebSocket long connection, so that the second module hot-replacement client sequentially sends a data request of page hot update to the module hot-replacement server through the channel of the second WebSocket long connection, the channel of the first WebSocket long connection and the channel of the third WebSocket long connection.
Optionally, the Electron desktop client is further configured to parse a configuration file contained in the page code through the local project packaging to obtain a parsed configuration file;
and the Electron desktop client is further used for adding a first script for creating a second module hot-replacement client into the configuration file obtained after analysis through the local project packaging service.
Optionally, the Electron desktop client is further configured to add a second script for creating a module hot-replacement server in the configuration file obtained after parsing through the local project packaging service;
the local project debugging service is used for creating the module hot replacement server according to the second script.
Optionally, the Electron desktop client is further configured to request to the node server to obtain session credential information;
the node server is further configured to generate session credential information when receiving a session credential information acquisition request sent by the electronic desktop client, and send the session credential information to the electronic desktop client, so that the WebSocket client establishes a first WebSocket long connection with the node server according to the session credential information.
Optionally, the node server is further configured to create a directory named as the session credential information in the static resource service after generating the session credential information.
Optionally, the Electron desktop client is further configured to start the local project debugging service through the local project packaging service.
Optionally, the Electron desktop client is further configured to upload the page code file package to a node server in an http request manner.
Optionally, the node server is further configured to return a network address of the static resource service to the Electron desktop client;
the Electron desktop client is used for generating a corresponding identification code according to the network address;
the mixed mode mobile application is further configured to scan the identifier code, and acquire and load the first code file from the static resource service according to the network address identified in the identifier code, so as to open the page to be debugged.
Optionally, the electronic desktop client is further configured to send, when receiving the modified page code, the modified page code to the second module hot-replacement client through the module hot-replacement server sequentially through the third WebSocket long connection channel, the first WebSocket long connection channel, and the second WebSocket long connection channel, so as to perform hot update on the page to be debugged through the second module hot-replacement client.
The application also provides a mixed mode mobile application debugging method, which is applied to a debugging system comprising debugging equipment, a node server and equipment to be debugged, wherein the equipment to be debugged is provided with an Electron desktop client and local project debugging service, and the method comprises the following steps:
creating a local project packaging service, a WebSocket client and a first module hot replacement client through the Electron desktop client, and establishing a first WebSocket long connection with the node server through the WebSocket client;
adding a first script for creating a second module hot-swap client in the page code of the mixed mode mobile application through the local project packaging service;
the server is replaced by the local project debugging service creation module, and the page codes containing the first script are packaged to generate a page code file catalog;
packaging the page code file catalogue by the Electron desktop client to generate a page code file package, and uploading the page code file package to the node server;
decompressing the page code file package through the node server to generate a first code file, and deploying the generated first code file into the static resource service;
Acquiring and loading the first code file from the static resource service through the mixed mode mobile application so as to open the page to be debugged;
creating a second module hot-replacement client according to a first script in the first code file through the mixed mode mobile application, and establishing a second WebSocket long connection with the node server through the second module hot-replacement client;
after the second WebSocket long connection is established, the node server informs the electronic desktop client side of establishing a third WebSocket long connection between the first module hot-replacement client side and the module hot-replacement server side through the first WebSocket long connection, so that the second module hot-replacement client side sequentially sends page hot-update data requests to the module hot-replacement server side through the second WebSocket long connection channel, the first WebSocket long connection channel and the third WebSocket long connection channel.
According to the mixed mode mobile application debugging system provided by the embodiment of the application, local project development is carried out by using the Electron desktop client, when the real machine is debugged on the real machine or the simulator, after the local code is modified, the Hybrid page on the real machine or the simulator can be updated thermally along with the code change. The front-end Hybrid development technician does not need to care how to modify project configuration, does not need to configure agents, and can have HMR hot update developed locally only by focusing on the service itself, so that configuration complexity is reduced.
Drawings
FIG. 1 schematically illustrates an environmental schematic of a mixed mode mobile application debugging system implementing an embodiment of the present application;
FIG. 2 schematically illustrates a block diagram of a mixed-mode mobile application debugging system in accordance with an embodiment of the present application;
fig. 3 schematically shows a flow diagram of a mixed mode mobile application debugging method according to an embodiment of the application.
Detailed Description
Advantages of the application are further illustrated in the following description, taken in conjunction with the accompanying drawings and detailed description.
Reference will now be made in detail to exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, the same numbers in different drawings refer to the same or similar elements, unless otherwise indicated. The implementations described in the following exemplary examples are not representative of all implementations consistent with the present disclosure. Rather, they are merely examples of apparatus and methods consistent with some aspects of the present disclosure as detailed in the accompanying claims.
The terminology used in the present disclosure is for the purpose of describing particular embodiments only and is not intended to be limiting of the disclosure. As used in this disclosure and the appended claims, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It should also be understood that the term "and/or" as used herein refers to and encompasses any or all possible combinations of one or more of the associated listed items.
It should be understood that although the terms first, second, third, etc. may be used in this disclosure to describe various information, these information should not be limited to these terms. These terms are only used to distinguish one type of information from another. For example, first information may also be referred to as second information, and similarly, second information may also be referred to as first information, without departing from the scope of the present disclosure. The word "if" as used herein may be interpreted as "at … …" or "at … …" or "responsive to a determination", depending on the context.
In the description of the present application, it should be understood that the numerical references before the steps do not identify the order in which the steps are performed, but are merely used to facilitate description of the present application and to distinguish between each step, and thus should not be construed as limiting the present application.
Fig. 1 schematically shows an application environment schematic of a mixed mode mobile application debugging system according to an embodiment of the application. In an exemplary embodiment, the system of the application environment may include a terminal device 10, a device 20 in which a mixed mode mobile application to be debugged is installed, and a server 30. Wherein a wireless or wired connection is formed between the terminal device 10, the device 20 in which the mixed mode mobile application to be debugged is installed, and the server 30. The terminal device 10 may be a tablet computer, a computer, etc., and is not limited herein. The device 20 on which the mixed mode mobile application to be debugged is installed may be an android phone, an android tablet, an iOS simulator, or the like. The server 30 may be a server cluster or a cloud computing center formed by one server or multiple servers. The server 30 is used to store the page code of the mixed mode mobile application to be debugged.
Referring to FIG. 2, a block diagram of a mixed mode mobile application debugging system according to an embodiment of the present application is shown. As can be seen from the figure, the mixed mode mobile application debugging system provided in the present embodiment includes a debugging device 200, a device 201 to be debugged, and a node server 202, wherein a desktop-adjusting window and a desktop client are installed in the debugging device 200, and the steps include:
the desktop client is configured to upload page codes of a mixed-mode mobile application to be debugged to the node server 202.
Specifically, the debugging device 200 refers to a device for debugging the debugging device 201 in the mixed mode mobile application debugging system. In this embodiment, before the mixed mode mobile application (Hybrid application) is debugged, the page code of the mixed mode mobile application needs to be uploaded to the node server 202 through the desktop client in the debugging device 200.
In an exemplary embodiment, the desktop client is an Electron desktop client, and the debugging device 200 further includes a local project debugging service installed in the debugging device 200.
The electronic desktop client is a MacOS, windows desktop client based on an electronic open source framework, and is a debugging coupling middle layer capable of realizing functions of a PC (computer), a node server 202, a true machine (Android mobile phone) or a simulator (iOS simulator), is a UI access layer of a user of the desktop client, and integrates multiple functions of a PC bottom layer system, webSocket communication, a chrome kernel control and the like. Specifically, the Electron desktop client can implement an AppleScript automation service and a node-simctl iOS simulator automation service, and implement an automation flow of all relevant links of the page HMR (hot module replacement, module hot replacement), including injection configuration, bridging middle layers, and the like.
In this embodiment, when the electronic desktop client 200 is started, it creates a WebSocket client and WebSocket server locally on the PC.
The WebSocket client may actively initiate a connection request to the node server 202, so as to establish a first WebSocket long connection between the two, and may forward the data acquired from the node server 202 to the WebSocket client through the first WebSocket long connection. The WebSocket client may also forward the data acquired from the WebSocket server (the data is acquired through an internal data channel between the WebSocket server and the WebSocket client) to the node server 202 through the first WebSocket long connection.
In an exemplary embodiment, to avoid having a device without rights also connect to the node server 202, the Electron desktop client is further configured to request the node server 202 to obtain session credential information; the node server 202 is configured to generate session credential information when receiving a session credential information acquisition request sent by the electronic desktop client, and send the session credential information to the electronic desktop client, so that the WebSocket client establishes a first WebSocket long connection with the node server 202 according to the session credential information.
Specifically, after receiving the request for obtaining the session credential information, the node server 202 may randomly generate session credential information, where the session credential information is a credential for establishing a connection with the node server 202, and only a device with the session credential may establish a connection with the node server 202.
The WebSocket server is used as a data transfer station for transferring relevant data by debugging data of a page to be debugged, HMR hot update data of the page to be debugged and a Service Worker hijacking request. The WebSocket server may be connected to a debugging tool (e.g., chrome Devtools Frontend debugging tool) to implement communication between the node server 202 and Chrome Devtools Frontend debugging tool, weback Service, hybrid application (mixed mode mobile application), a page to be debugged, and a Service Worker.
In this embodiment, after the electronic desktop client is started, it also creates a first module hot-swap client locally on the PC.
Specifically, the first module hot-replacement client is a local WebSocket client created by the Electron desktop client and is used for communicating with the module hot-replacement server to realize the exchange of HMR hot-update JSON data.
In this embodiment, in order to process the page code through the local project debugging service in time, after the electronic desktop client is started, it also creates a local project packaging service locally on the PC, so as to start the local project debugging service through the local project packaging service.
Specifically, the local project packaging service is a weback development server created by a subprocess of the Electron client, and is used for executing starting the local project debugging service to process the page code by the local project debugging service.
In this embodiment, the electronic desktop client is further configured to add, through the local project packaging service, a first script for creating a second module hot-swap client and add a second script for creating a module hot-swap server to the page code.
Specifically, when the weback starts the DevServer mode, the WebSocket server locally created by the weback is used for the first module hot replacing client to connect and provide HMR hot updating JSON data.
The first script is a JavaScript script for replacing a module hot-replacement client built in the weback, and when the page code is loaded, webSocket long connection is established with a module hot-replacement server built in the weback by adding the first script into the page code, so that JSON data of HMR hot update is exchanged. In this embodiment, the second module hot replacement client created by the first script may change the destination address of the HMR hot update default WebSocket long connection of the page to be debugged to be the node server 202 address, and is used to forward JSON data of the HMR hot update to the node server 202.
The Webpack is a module packer, and mainly aims to pack JavaScript code files running on a browser.
It should be noted that, HMR hot update, i.e. hot replacement of a module, is a function that can replace, add or delete a module during the running process of an application program, without reloading the whole page. The method has the following characteristics:
1. the page state (page state includes form, route, etc. states) is preserved.
2. Only the change content is updated, and the speed of packing, page loading and page presenting is faster, so that precious development time is saved.
3. When the CSS/JS is modified in the source code, it is updated immediately in the browser, which is almost equivalent to directly changing the style in the browser devtools.
The second script is also a JavaScript script, and can be used for replacing a module hot-replacement server side built in the weback, specifically, the JavaScript core is to change a serverPath path of the built-in module hot-replacement server side into a custom path, so that WebSocket long connection can be established with a built module hot-replacement client side.
In an exemplary embodiment, when the first script and the second script are added to the page code through the local project packaging service, the configuration file code included in the page code may be parsed to obtain a gitigore configuration and a git filemode configuration, the first script and the second script are added to the configuration file obtained after parsing, and after the addition of the first script and the second script is completed, a new project configuration file may be generated according to an existing config configuration file.
In this embodiment, after the local project packaging service finishes adding the first script and the second script in the page code, the local project debugging service may create a module hot replacement server according to the second script.
The local project debugging service can also package the page codes containing the first script to generate a page code file directory.
The local project debugging service is a Dev operation service of a local front-end project based on Webpack.
The page code file directory refers to a dist file that includes a plurality of files, such as a dist file containing project static resources html, css, js file, and the like.
In this embodiment, the local project debugging Service is further configured to add a code segment for loading a third script of a Service workbench to a preset file in the page code file directory, and add the third script to the page code file directory.
The Service Worker is an event driven Worker registered under a specified source and path, and uses JavaScript to control an associated page or website, intercept and modify access and request resources, and cache resources with fine granularity. Essentially acting as a proxy server between the Web application, browser and network. It runs in the workbench context, i.e. in other threads than the browser main thread, so that it cannot access the page DOM, and it does not cause blocking, but can only be carried by HTTPS, which is a thread completely asynchronous with the browser main thread.
In this embodiment, in order to intercept all HTTP/HTTPs network requests in a current page to be debugged through a Service workbench when loading the page to be debugged, modification of network requests and response results is implemented, and then the modified network requests and response results are returned to the current page to be debugged as network request results of the current page to be debugged. In this embodiment, a code segment for loading a Service workbench script may be added in advance in the page code file directory, so that when a page code is loaded, another thread may be started through the code segment to run a third script of the Service workbench, so as to implement takeover of a current page to be debugged.
In this embodiment, the preset file is a preset file for adding a code segment, which is specifically an html file in the page code file object.
In this embodiment, after the code segments are added, a third script of JavaScript of Service workbench may be placed under the page code file directory, so that the script of Service workbench may be packaged together with other static resource files in the page code file directory by the electronic desktop client to generate a page code file package, and the page code file package is uploaded to the node server 202.
In an exemplary embodiment, the electronic desktop client may package the page code file directory including the third script into a tar package, so that the electronic desktop client may upload the tar package to the node server 202 by using an HTTP request, and in particular, the electronic desktop client may put the tar package into a Body of the HTTP request.
The node server 202 is configured to deploy the received page code to a static resource service, and return a network address of the static resource service to the debug apparatus 201.
Specifically, the node server 202 may be deployed in a public network environment, and is used for carrying API interface services, managing WebSocket long connection data interaction, and responsible for receiving, decompressing, managing Session credentials (Session Id) and project static resources of different clients, providing static resource services, and the like. The static resource service is a container in node server 202 for storing page code.
In this embodiment, after receiving the page code uploaded by the debug apparatus 201, the node server 202 deploys the received page code to the static resource service, and returns the network address of the static resource service to the debug apparatus 201.
In an exemplary embodiment, when the page code received by the node server 202 is a page code file package generated by packaging an Electron desktop client, the node server 202 is further configured to decompress the page code file package to generate a first code file, deploy the generated first code file to the static resource service, and return a network address of the static resource service to the Electron desktop client.
It will be appreciated that when the page code received by the node server 202 is in the form of a file package, the page code file package needs to be decompressed first, and then the first code file obtained by decompression is deployed to the static resource service, so that the device to be debugged can obtain the first code file from the static resource service.
In an exemplary embodiment, in order to quickly find the page code (or the first code file) stored in the static resource service, the node server 202 may create a directory named as the session credential information in the static resource service after generating the session credential information, so that when the page code file (or the first code file) is deployed, the received page code file package may be decompressed later, and the page code obtained after the decompression is deployed under the directory named as the session credential information.
The device to be debugged 203 is configured to obtain the network address from the debugging device 201, and obtain and load the page code from the static resource service according to the network address, so as to open a page to be debugged.
Specifically, the device to be debugged 203 is a device that needs to be debugged by the debugging device 201. In this embodiment, when the device to be debugged is debugged, the device to be debugged will first acquire the network address from the debug device 201, so that the page code can be acquired and loaded from the static resource server according to the network address, thereby opening the page to be debugged.
The debugging device 202 is further configured to debug the page to be debugged through a debugging tool installed in the debugging device 202.
Specifically, the debugging tool is a tool that needs to be used in the process of remotely debugging the device to be debugged 203. In this embodiment, when the page to be debugged is opened during debugging, the remote page debugging can be directly performed on the page to be debugged through the debugging tool. The page debugging may include page debugging operations such as review element, console printing, view Network, memory management, and the like.
In an exemplary embodiment, the device to be debugged 203 may include an android device installed with the mixed mode mobile application. The Android device refers to a device using an Android system.
The debugging tools comprise Chrome Devtools Frontend debugging tools, chrome Devtools Frontend debugging tools are used for performing page debugging based on Chrome Devtools Protocol cross-end debugging protocol, page debugging data interaction is performed based on JSON format data, no equipment limitation exists, and most main stream browsers and Webview based on Chromium, blink kernels in the market can be used for achieving cross-end debugging.
The mixed mode mobile application is used for acquiring and loading the first code file from the static resource service so as to open the page to be debugged.
Specifically, in order to enable the mixed-mode mobile application to conveniently acquire and load the first code file from the static resource service, the Electron desktop client may generate a corresponding identification code according to the network address after receiving the network address returned by the node server 202, where the identification code may be a two-dimensional code, a barcode, or the like. In this way, when the mixed mode mobile application needs to acquire the first code file, the barcode can be scanned to acquire the network address from the barcode, and then the first code file is acquired and loaded from the static resource service according to the network address to open the page to be debugged.
In an embodiment, in order to facilitate the establishment of WebSocket long connection between the subsequent mixed mode mobile application and the node server 202, the electronic desktop client may further splice the session credential information with the network address, and generate a corresponding identification code according to the character information obtained after the splicing; the mixed mode mobile application is further configured to establish the fourth WebSocket long connection with the node server 202 according to the session credential information identified from the identification code.
The mixed mode mobile application is further configured to load the third script according to the code segment in the first code file, intercept a network request of the page to be debugged through the third script, and create the second module hot-swap client according to the first script in the first code file.
Specifically, since the acquired first page code includes a code section for loading the third script (script of Service workbench), during the process of loading the acquired first page code file, the script of Service workbench can be loaded at the same time, and the network request of the page to be debugged is intercepted by the Service workbench, so that the request address of the intercepted network request can be modified to be the API interface Service address of the node server 202.
In an exemplary embodiment, when the Service Worker modifies the request address of the intercepted network request to the API Service address of the node server 202, the node server 202 sends the network request to the WebSocket client through the first WebSocket long connection. And after receiving the network request, the WebSocket client carries out domain name resolution on the network request through the Electron desktop client, and sends the network request to a server according to the address obtained after the resolution. The server may respond to the network request after receiving the network request.
The server is a server for deploying the API interface service, and is typically deployed in various environments, such as testing, PRE, and formal environments, and used for front-end and back-end joint debugging in different stages.
In an exemplary embodiment, after the node server 202 receives the network request through the API service address, the network request is parsed, and the first network request obtained after the parsing is encapsulated into a second network request including a request sequence number, a request address, a request mode, a request header, and a request body.
In an exemplary embodiment, after receiving the network request, the server responds to the network request to generate a response result, and returns the response result to the Electron desktop client. In this embodiment, after the Electron desktop client receives the response result returned by the server, the response result may be encapsulated, and the encapsulated first response result may be sent to the node server 202 through the WebSocket client; then, the node server 202 analyzes the received first response result, and returns a second response result obtained after the analysis to the Service workbench, so that the Service workbench uses the second response result as a response result of the network request included in the page to be debugged.
In one embodiment, in order to facilitate analysis of the response results, after the Electron desktop client receives the first response result, the received first response result is encapsulated into a second response result including a response sequence number, a response status code, response status information, a response header, and a response body.
And the second module is used for thermally replacing the client and establishing a second WebSocket long connection with the node server.
Specifically, the second module hot replacing client is a WebSocket client created when the first page code file is loaded, and is used for establishing WebSocket long connection with the module hot replacing server, and exchanging HMR hot updating JSON data. In this embodiment, after receiving the JSON data of the HMR hot update, the second module hot replacement client actively loads the packaged hot module file to replace the local module in the page to be debugged, so as to achieve the effect of hot update.
The mixed mode mobile application is further used for starting a Webview debugging mode, so that the android device calls a Chromium kernel to create a Unix Domain Socket server according to the Webview debugging mode.
Specifically, the Webview debug mode is a mode for remotely debugging an application. Unix Domain Socket the service end is a service for providing JSON data for external connection, communication and exchange of Hybrid page debugging, the process ID format is @ webview_devtools_remote_remote $ { pid }, and pid is Webview process ID. When the Unix Domain Socket server communicates with the Hybrid application, an IPC (Inter-Process-Communication) Communication mode based on a file system and not needing to be transmitted through a network is adopted, and the Communication mode is not needed to be subjected to processes such as network packing, checking and unpacking, so that the reliability and the efficiency are higher.
The mixed mode mobile application is further configured to establish a third WebSocket long connection with the Unix Domain Socket server, and to establish a fourth WebSocket long connection with the node server 202.
Specifically, when the mixed-mode mobile application establishes a fourth WebSocket long connection with the node server 202, the session credential information may be identified from the identification code, and then the fourth WebSocket long connection may be established with the node server 202 by means of the session credential information, so that debug JSON data of the page to be debugged may be exchanged through the fourth WebSocket long connection pre-node server 202.
In an exemplary embodiment, the Unix Domain Socket server has corresponding process identification information, and the mixed mode mobile application is further configured to obtain the process identification information of a plurality of processes currently started in the android device, and search the Unix Domain Socket server according to each process identification information; the mixed mode mobile application is further configured to initiate a handshake request to the Unix Domain Socket server, and send a protocol upgrade instruction to the Unix Domain Socket server after handshake is successful, so as to upgrade the current communication protocol to a WebSocket protocol.
Specifically, the process identification information is information for distinguishing different processes, the hybrid mode mobile application can use a LocalSocket library to find a corresponding process corresponding to a corresponding Unix Domain Socket server according to the process identification information of each currently opened process, then initiate a handshake request to the found process, and send an HTTP message to the Socket after handshake is successful to upgrade the current communication protocol into a WebSocket protocol. After the upgrade is successful, the mixed mode mobile application can communicate with the Unix Domain Socket Server server by corresponding messages based on the WebSocket protocol.
The desktop client is also used for opening the desktop adjustable window;
the desktop adjusting window is used for loading a debugging tool installed in the debugging equipment to debug the page to be debugged.
Specifically, the desktop client may open a desktop debug window through the WebSocket client, and load a debug tool (such as the Chrome Devtools Frontend debug tool) installed in the debug device on the desktop debug window to debug the page to be debugged.
Specifically, the Chrome Devtools Frontend debugging tool is used for debugging the front end UI of the page, can be separated from the Chrome kernel and independently run as a front end project, communicates with the Chrome kernel through a WebSocket protocol, exchanges debugging data in a JSON format, and achieves the development effect of the embedded Devtools in the Chrome.
The Chrome Devtools Frontend debugging tool is configured to establish a fifth WebSocket long connection with the WebSocket server, so as to exchange debugging data with the chromoum kernel through the fifth WebSocket long connection to realize debugging of the page to be debugged.
Specifically, when the Chrome Devtools Frontend debugging tool establishes the fifth WebSocket long connection with the WebSocket server, address information of the WebSocket server can be acquired through the WebSocket client, and then the WebSocket long connection can be established with the WebSocket server according to the acquired address information of the WebSocket server.
In an embodiment, when the Chrome Devtools Frontend debugging tool implements debugging the page to be debugged through the fifth WebSocket long connection, a debugging request may be sent to the WebSocket server through the fifth WebSocket long connection, so that the WebSocket server may send the debugging request to the Unix Domain Socket server through the WebSocket client, the channel of the first WebSocket long connection, the channel of the fourth WebSocket long connection, and the channel of the third WebSocket long connection in sequence, so as to implement debugging of the page to be debugged.
In another embodiment, when the debugging tool performs debugging on the page to be debugged through the fifth WebSocket long connection, the debugging tool may send a debug information acquisition request of the Hybrid page to be debugged to the WebSocket server through the fifth WebSocket long connection to the WebSocket server, so that the WebSocket server may send the debug information acquisition request to the Unix Domain Socket server through the WebSocket client, the channel of the first WebSocket long connection, the channel of the fourth WebSocket long connection and the channel of the third WebSocket long connection in sequence, thereby implementing obtaining debug information of the page to be debugged from the Unix Domain Socket server, and performing a debugging operation according to the obtained debug information.
In an exemplary embodiment, in order to debug the page to be debugged in time, the mixed mode mobile application is further configured to send, to the node server 202, a signal that a debug channel of the page to be debugged is opened through a fourth WebSocket long connection after the fourth WebSocket long connection is established with the node server 202; the node server 202 is further configured to send the signal to the WebSocket client through the first WebSocket long connection after receiving the signal, so that the WebSocket client opens the desktop debug window after receiving the signal.
In this embodiment, the desktop debug window is opened only when a signal that the debug channel is opened is received, so that the page to be debugged is formally started to debug the page.
The node server 202 is further configured to notify, after the second WebSocket long connection is established, the Electron desktop client to establish a sixth WebSocket long connection between the first module hot-replacement client and the module hot-replacement server through the first WebSocket long connection, so as to implement hot update of the page through the sixth WebSocket long connection.
Specifically, after the second WebSocket long connection is established, the node server 202 notifies the Electron desktop client to establish a sixth WebSocket long connection between the first module hot-swap client and the module hot-swap server through the first WebSocket long connection, so that the second module hot-swap client can send a data request of page hot-swap to the module hot-swap server through the channel of the second WebSocket long connection, the channel of the first WebSocket long connection and the channel of the sixth WebSocket long connection in sequence, and achieve acquisition of the data of page hot-swap.
In an exemplary embodiment, after the page code is modified, the electronic desktop client may further send the modified page code to the second module hot-replacement client through the module hot-replacement server sequentially through the sixth WebSocket long connection channel, the first WebSocket long connection channel, and the second WebSocket long connection channel, so that the second module hot-replacement client may implement hot update of the page according to the modified page code.
In an exemplary embodiment, the device 201 to be debugged further comprises an iOS simulator, and the debug tool further comprises a Safari browser, wherein:
the Electron desktop client is also used for creating an AppleScript automation service and an iOS simulator automation service.
Specifically, appleScript is a scripting language created by apple corporation, is suitable for MacOS 7.1 and higher, allows a user to directly control a script-writable MacOS application program and a part of built-in functions and applications of the MacOS itself, and can help the user to control the application program in the MacOS by using the AppleScript script, such as a system event, a Safari browser, an iOS Simulator, and the like, and an AppleScript automation service written by the AppleScript can be used for opening a Safari developer tool of the Safari browser.
The iOS simulator automation service is a service for controlling the iOS simulator by executing xcrun simctl command using node-simctl three-party library, including starting up, closing the simulator, installing App, opening URL, etc.
Wherein xcrun is a command line tool provided by Xcode application under MacOS for controlling Xcode development related functions.
simctl is a subcommand of the xcrun tool that controls the simulator, providing the functions of starting up, closing, installing applications, opening URLs, etc. of the simulator.
Node-simctl is a Node version three-party library of simctl tools provided by the app for controlling the iOS Simulator in the Node program.
The electronic desktop client is further configured to start the iOS simulator through the iOS simulator automation service, install the mixed mode mobile application through the iOS simulator automation service after the iOS simulator is started, and open the network address in the iOS simulator through the iOS simulator automation service after the mixed mode mobile application is installed, so that the mixed mode mobile application calls a WKWebview kernel to load the page to be debugged.
Specifically, the iOS simulator is software for simulating real iOS equipment, in this embodiment, in order to save time spent in a debugging process, the iOS simulator is automatically started by an iOS simulator automation service, after the iOS simulator is started, the mixed mode mobile application is installed by the iOS simulator automation service, after the mixed mode mobile application is installed, the network address is opened in the iOS simulator by the iOS simulator automation service, so that the mixed mode mobile application is installed in the iOS simulator automatically, and the page to be debugged is opened by the mixed mode mobile application.
The WKWeBView kernel is the core of the modern WebKit API in iOS 8 and OS X Yosmeite applications. It replaces uifebview in UIKit and WebView in AppKit, providing a unified cross-dual platform API (iOS and OS).
In an exemplary embodiment, to avoid having multiple iOS emulators turned on at the same time, in this embodiment, when the iOS emulators are turned on by the iOS emulator automation service, the electronic desktop client may first turn off all the iOS emulators that are currently turned on by the iOS emulator automation service, and after all the iOS emulators are turned off, re-turn on the iOS emulators selected by the default or the user. Thereafter, the mixed-mode mobile application may be installed through the iOS simulator automation service.
In an exemplary embodiment, after completing the installation of the mixed-mode mobile application, the Electron desktop client may also install a test environment certificate (e.g., SSL certificate) through the iOS simulator automation service so that the mixed-mode mobile application may access the HTTPS service of the test environment.
In an exemplary embodiment, after the electronic desktop client opens the network address in the iOS simulator through the iOS simulator automation service, the mixed mode mobile application may be opened through URL scheme, so that the mixed mode mobile application may call a WKWebview kernel to load the page to be debugged.
Among them, URL scheme is supported by most APPs currently, which has a function of calling the App and opening a corresponding page when a browser in a real machine opens the URL.
Starting from iOS 8, WKWebview gradually replaces uifebview, becoming Webview mainly used by iOS App, which is based on Webkit kernel.
In an exemplary embodiment, the invoking the WKWebview kernel by the mixed-mode mobile application to load the page to be debugged includes: and the mixed mode mobile application calls the WKWeBview kernel to start a WKWeBview kernel debugging service, and calls the WKWeBview kernel to render the page to be debugged by adopting a Webkit engine.
Specifically, the WKWebview kernel debugging service is a Webview debugging service which is started locally by the WKWebview kernel and is similar to an Android chromoum kernel debugging service. However, due to the limitation of iOS, conventionally, a third party application cannot control rendering and internal debugging of WKWebview, and cannot contact the WKWebview kernel debugging service, and only a Safari developer tool can communicate with the service and debug, and the debugging protocol is based on a Webkit-like kernel debugging protocol. After the kernel debugging service is started, the WKWebview kernel adopts a Webkit engine to render the page to be debugged.
The Electron desktop client is further used for opening a Safari developer tool from the Safari browser through an AppleScript automation service.
Specifically, the electronic desktop client may simulate clicking on the Safari developer tool in the Safari browser through the AppleScript automation service to open the Safari developer tool.
The Safari developer tool is a tool provided by a Safari browser and used for debugging an iOS true machine or simulator, and is similar to a Chrome Devtools tool, and can perform debugging functions such as element examination, console printing, network request management and the like.
The Safari developer tool is used for establishing a connection channel with the WKWEBview kernel through a Safari debugging protocol and realizing the debugging of a page to be debugged through the connection channel.
Specifically, after a connection channel is established between the Safari developer tool and the WKWebview kernel debugging service of the iOS simulator, page debugging data can be exchanged based on the class Webkit debugging protocol communication, and page debugging with complete functionality is performed.
According to the mixed mode mobile application debugging system, a front-end developer can directly remotely debug Hybrid pages on Android 4.4 and above various Android true machines by using Chrome Devtools Frontend debugging tools in a desktop debugging window opened by an Electron desktop client, so that a debugging effect similar to that of debugging PC pages by using tools of a Chrome built-in developer is obtained, and Charles agents, USB hardware equipment connection and the like are not needed, so that cost and complexity can be reduced.
Referring to fig. 3, the method for debugging a mixed mode mobile application according to an embodiment of the present application is applied to a debugging system including a debugging device, a node server, and a device to be debugged, in which an Electron desktop client and a local project debugging service are installed in the debugging device, where the mixed mode mobile application debugging system is the mixed mode mobile application debugging system in the above embodiment, and will not be described in detail in this embodiment.
In this embodiment, the method includes:
step S30, a local project packaging service, a WebSocket client and a first module hot replacement client are created through the Electron desktop client, and a first WebSocket long connection is established between the WebSocket client and the node server;
step S31, adding a first script for creating a second module hot-swap client in the page code of the mixed mode mobile application through the local project packaging service;
step S32, hot replacing a server through the local project debugging service creation module, and packaging page codes containing the first script to generate a page code file catalog;
step S33, packaging the page code file catalogue through the electronic desktop client to generate a page code file package, and uploading the page code file package to the node server;
step S34, decompressing the page code file package through the node server to generate a first code file, and deploying the generated first code file into the static resource service;
step S35, the first code file is obtained and loaded from the static resource service through the mixed mode mobile application so as to open the page to be debugged;
Step S36, a second module hot-replacement client is established according to a first script in the first code file through the mixed mode mobile application, and a second WebSocket long connection is established between the second module hot-replacement client and the node server;
step S37, after the second WebSocket long connection is established, the node server notifies, through the first WebSocket long connection, the electronic desktop client to establish a third WebSocket long connection between the first module hot-swap client and the module hot-swap server, so that the second module hot-swap client sequentially sends a data request of page hot-swap to the module hot-swap server through the channel of the second WebSocket long connection, the channel of the first WebSocket long connection, and the channel of the third WebSocket long connection.
According to the mixed mode mobile application debugging method, a front-end developer can directly remotely debug Hybrid pages on Android 4.4 and above various Android true machines by using Chrome Devtools Frontend debugging tools in a desktop debugging window opened by an Electron desktop client, so that a debugging effect similar to that of debugging PC pages by using tools of a Chrome built-in developer is obtained, and Charles agents, USB hardware equipment connection and the like are not needed, so that cost and complexity can be reduced.
The apparatus embodiments described above are merely illustrative, wherein elements illustrated as separate elements may or may not be physically separate, and elements shown as elements may or may not be physical elements, may be located in one place, or may be distributed over at least two network elements. Some or all modules in the system can be screened out according to actual needs to realize the purpose of the scheme of the embodiment of the application. Those of ordinary skill in the art will understand and implement the present application without undue burden.
From the above description of embodiments, it will be apparent to those skilled in the art that the embodiments may be implemented by means of software plus a general purpose hardware platform, or may be implemented by hardware. Those skilled in the art will appreciate that all or part of the processes implementing the methods of the above embodiments may be implemented by a computer program for instructing relevant hardware, where the program may be stored in a computer readable storage medium, and where the program may include processes implementing the embodiments of the methods described above. The storage medium may be a magnetic disk, an optical disk, a Read-only memory (ROM), a random access memory (RandomAccessMemory, RAM), or the like.
Finally, it should be noted that: the above embodiments are only for illustrating the technical solution of the present application, and not for limiting the same; although the application has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some or all of the technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit of the application.
Claims (10)
1. The utility model provides a mixed mode mobile application debugging system which characterized in that, the debugging system includes debugging equipment, node server and installs the equipment of waiting to debug of the mixed mode mobile application of waiting to debug, install Electron desktop client and local project debugging service in the debugging equipment, wherein:
the Electron desktop client is used for creating a local project packaging service, a WebSocket client and a first module hot replacement client, and is used for establishing a first WebSocket long connection with the node server through the WebSocket client;
the electronic desktop client is further used for adding a first script for creating a second module hot-replacement client in the page code of the mixed-mode mobile application through the local project packaging service;
The local project debugging service is used for creating a module hot replacement server and packaging page codes containing the first script to generate a page code file directory;
the Electron desktop client is further configured to package the page code file directory to generate a page code file package, and upload the page code file package to the node server;
the node server is used for decompressing the page code file package to generate a first code file and deploying the generated first code file into a static resource service;
the mixed mode mobile application is used for acquiring and loading the first code file from the static resource service so as to open a page to be debugged;
the mixed mode mobile application is further configured to create a second module hot-swap client according to a first script in the first code file, and establish a second WebSocket long connection with the node server through the second module hot-swap client;
the node server is further configured to notify, after the second WebSocket long connection is established, the electronic desktop client to establish a third WebSocket long connection between the first module hot-replacement client and the module hot-replacement server through the first WebSocket long connection, so that the second module hot-replacement client sequentially sends a data request of page hot update to the module hot-replacement server through the channel of the second WebSocket long connection, the channel of the first WebSocket long connection and the channel of the third WebSocket long connection.
2. The mixed-mode mobile application debugging system of claim 1, wherein the Electron desktop client is further configured to parse a configuration file contained in the page code through the local project packaging to obtain a parsed configuration file;
and the Electron desktop client is further used for adding a first script for creating a second module hot-replacement client into the configuration file obtained after analysis through the local project packaging service.
3. The mixed-mode mobile application debugging system according to claim 2, wherein the Electron desktop client is further configured to add a second script for creating a module hot-replacement server to the configuration file obtained after parsing by the local project packaging service;
the local project debugging service is used for creating the module hot replacement server according to the second script.
4. The mixed-mode mobile application debugging system of claim 1, wherein an Electron desktop client is further configured to request to the node server to obtain session credential information;
the node server is further configured to generate session credential information when receiving a session credential information acquisition request sent by the electronic desktop client, and send the session credential information to the electronic desktop client, so that the WebSocket client establishes a first WebSocket long connection with the node server according to the session credential information.
5. The mixed-mode mobile application debugging system of claim 4, wherein the node server is further configured to create a directory named the session credential information in the static resource service after generating the session credential information.
6. The mixed-mode mobile application debugging system of claim 4, wherein the Electron desktop client is further configured to turn on the local project debugging service through the local project packaging service.
7. The mixed-mode mobile application debugging system of any of claims 1-6, wherein the Electron desktop client is further configured to upload the page code file package to a node server in the form of an http request.
8. The mixed-mode mobile application debugging system of claim 1, wherein the node server is further configured to return a network address of the static resource service to the Electron desktop client;
the Electron desktop client is used for generating a corresponding identification code according to the network address;
the mixed mode mobile application is further configured to scan the identifier code, and acquire and load the first code file from the static resource service according to the network address identified in the identifier code, so as to open the page to be debugged.
9. The mixed-mode mobile application debugging system according to claim 1, wherein the electronic desktop client is further configured to send, when receiving the modified page code, the modified page code to the second module hot-replacement client through the module hot-replacement server sequentially through the third WebSocket long connection channel, the first WebSocket long connection channel, and the second WebSocket long connection channel, so as to perform hot-update on the page to be debugged through the second module hot-replacement client.
10. The utility model provides a mixed mode mobile application debugging method, is applied to the debugging system that includes debugging equipment, node server and installs the equipment of waiting to debug of mixed mode mobile application to wait to debug, install Electron desktop client and local project debugging service in the debugging equipment, characterized in that, the method includes:
creating a local project packaging service, a WebSocket client and a first module hot replacement client through the Electron desktop client, and establishing a first WebSocket long connection with the node server through the WebSocket client;
Adding a first script for creating a second module hot-swap client in the page code of the mixed mode mobile application through the local project packaging service;
the server is replaced by the local project debugging service creation module, and the page codes containing the first script are packaged to generate a page code file catalog;
packaging the page code file catalogue by the Electron desktop client to generate a page code file package, and uploading the page code file package to the node server;
decompressing the page code file package through the node server to generate a first code file, and deploying the generated first code file into a static resource service;
acquiring and loading the first code file from the static resource service through the mixed mode mobile application so as to open a page to be debugged;
creating a second module hot-replacement client according to a first script in the first code file through the mixed mode mobile application, and establishing a second WebSocket long connection with the node server through the second module hot-replacement client;
after the second WebSocket long connection is established, the node server informs the electronic desktop client side of establishing a third WebSocket long connection between the first module hot-replacement client side and the module hot-replacement server side through the first WebSocket long connection, so that the second module hot-replacement client side sequentially sends page hot-update data requests to the module hot-replacement server side through the second WebSocket long connection channel, the first WebSocket long connection channel and the third WebSocket long connection channel.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110919363.5A CN113641580B (en) | 2021-08-11 | 2021-08-11 | Mixed mode mobile application debugging method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110919363.5A CN113641580B (en) | 2021-08-11 | 2021-08-11 | Mixed mode mobile application debugging method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113641580A CN113641580A (en) | 2021-11-12 |
| CN113641580B true CN113641580B (en) | 2023-10-20 |
Family
ID=78420822
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110919363.5A Active CN113641580B (en) | 2021-08-11 | 2021-08-11 | Mixed mode mobile application debugging method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113641580B (en) |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101996093A (en) * | 2009-08-10 | 2011-03-30 | 日电（中国）有限公司 | Method and system for converting desktop application to network application |
| KR20140019623A (en) * | 2012-08-06 | 2014-02-17 | 인크로스 주식회사 | An integrated platform for authoring web applications and the authoring method thereof |
| CN109032917A (en) * | 2017-06-09 | 2018-12-18 | 北京金山云网络技术有限公司 | Page adjustment method and system, mobile terminal and computer end |
| CN109582317A (en) * | 2018-11-30 | 2019-04-05 | 百度在线网络技术（北京）有限公司 | Method and apparatus for debugging boarding application |
| CN111352847A (en) * | 2020-03-09 | 2020-06-30 | 中国邮政储蓄银行股份有限公司 | Real-time debugging method and system for mobile application terminal |
| WO2020177519A1 (en) * | 2019-03-05 | 2020-09-10 | 中国银联股份有限公司 | Debugging method executed on smart terminal and software debugging device |
| CN112463602A (en) * | 2020-11-24 | 2021-03-09 | 上海哔哩哔哩科技有限公司 | User interface testing method and system |
| CN113220571A (en) * | 2021-05-11 | 2021-08-06 | 北京百度网讯科技有限公司 | Debugging method, system, equipment and storage medium of mobile webpage |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8806469B2 (en) * | 2011-02-22 | 2014-08-12 | International Business Machines Corporation | Runtime code replacement |
-
2021
- 2021-08-11 CN CN202110919363.5A patent/CN113641580B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101996093A (en) * | 2009-08-10 | 2011-03-30 | 日电（中国）有限公司 | Method and system for converting desktop application to network application |
| KR20140019623A (en) * | 2012-08-06 | 2014-02-17 | 인크로스 주식회사 | An integrated platform for authoring web applications and the authoring method thereof |
| CN109032917A (en) * | 2017-06-09 | 2018-12-18 | 北京金山云网络技术有限公司 | Page adjustment method and system, mobile terminal and computer end |
| CN109582317A (en) * | 2018-11-30 | 2019-04-05 | 百度在线网络技术（北京）有限公司 | Method and apparatus for debugging boarding application |
| WO2020177519A1 (en) * | 2019-03-05 | 2020-09-10 | 中国银联股份有限公司 | Debugging method executed on smart terminal and software debugging device |
| CN111352847A (en) * | 2020-03-09 | 2020-06-30 | 中国邮政储蓄银行股份有限公司 | Real-time debugging method and system for mobile application terminal |
| CN112463602A (en) * | 2020-11-24 | 2021-03-09 | 上海哔哩哔哩科技有限公司 | User interface testing method and system |
| CN113220571A (en) * | 2021-05-11 | 2021-08-06 | 北京百度网讯科技有限公司 | Debugging method, system, equipment and storage medium of mobile webpage |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113641580A (en) | 2021-11-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106776313B (en) | Method and device for simulating service and centralized management platform | |
| US11057469B2 (en) | Method and apparatus for service hosting of distributed storage system | |
| CN107704395B (en) | Cloud platform automation test implementation method and system based on Openstack | |
| CN113641582A (en) | Mixed-mode mobile application debugging method and system | |
| US11513789B2 (en) | Application deployment method, apparatus, and system | |
| CN113641581B (en) | Mixed mode mobile application debugging method and system | |
| US20170154017A1 (en) | Web Application Management | |
| CN106126273B (en) | A kind of method of upgrading BIOS | |
| CN111459539B (en) | Continuous integration pipeline operation method and device based on mirror layering | |
| CN112732572A (en) | Service testing method, device and system, storage medium and electronic device | |
| CN108280174A (en) | Front end file construction method and server, page access method and terminal | |
| CN103634393A (en) | IVR (interactive voice response) and realization method thereof | |
| CN111104336A (en) | Online service interface testing method and device based on container and VNC | |
| CN113626330A (en) | Mixed-mode mobile application debugging method and system | |
| CN113641580B (en) | Mixed mode mobile application debugging method and system | |
| CN106648805A (en) | Intelligent device, intelligent system, and method for intelligently installing application | |
| CN114915565B (en) | Network debugging method and system | |
| CN110673835A (en) | Dynamic assembly type development system, method, computer and computer program | |
| CN110674435A (en) | Page access method, server, terminal, electronic equipment and readable storage medium | |
| CN113626329A (en) | Mixed-mode mobile application debugging system | |
| CN102137058B (en) | A kind of page access method and apparatus based on tab page | |
| CN112433938A (en) | Method and device for testing application of mobile terminal | |
| CN109597952B (en) | Webpage information processing method, system, electronic equipment and storage medium | |
| CN110837612A (en) | Method and device for acquiring Uniform Resource Identifier (URI) data and storage medium | |
| CN113068216A (en) | Network dial testing method, network dial testing system and computer readable storage medium |
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 |