CN113641581A - Mixed-mode mobile application debugging method and system - Google Patents
Mixed-mode mobile application debugging method and system Download PDFInfo
- Publication number
- CN113641581A CN113641581A CN202110920806.2A CN202110920806A CN113641581A CN 113641581 A CN113641581 A CN 113641581A CN 202110920806 A CN202110920806 A CN 202110920806A CN 113641581 A CN113641581 A CN 113641581A
- Authority
- CN
- China
- Prior art keywords
- service
- debugging
- page
- mixed
- mobile application
- 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.)
- Granted
Links
Images
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
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Software Systems (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Human Computer Interaction (AREA)
- Debugging And Monitoring (AREA)
Abstract
An embodiment of the present application provides a mixed-mode mobile application debugging system, including: the system comprises an Electron desktop client, a node server and a Web server, wherein the Electron desktop client is used for creating a WebSocket client and a local project debugging Service, establishing WebSocket long connection with the node server through the WebSocket client, packaging page codes through the local project debugging Service to generate a file, adding a code segment for loading a script of a Service Worker into the file, packaging the file and the script of the Service Worker to obtain a packaged file, and uploading the packaged file to the node server; the node server is used for decompressing the packed file, deploying the packed file into the static resource service, and returning the network address of the static resource service to the Electron desktop client; the Hybrid application is used for acquiring a page code from a static resource Service according to a network address, loading the page code, and loading the Service Worker script when the page code is loaded so as to intercept a network request of a page to be debugged through the Service Worker. The configuration complexity can be reduced.
Description
Technical Field
The embodiment of the application relates to the technical field of computers, in particular to a mixed-mode mobile application debugging method and system.
Background
Hybrid applications have emerged due to the updating of computer application technology and market needs. Hybrid applications are mixed-mode mobile applications that are intermediate between Native apps and Web apps. After the Hybrid application is developed, the Hybrid application needs to be remotely debugged in order to find out problems existing in the development process. However, the inventor finds that, when the front-end and back-end joint debugging is performed on the Android native machine, for an App application which does not modify an App environment and DNS resolution rules, the Hybrid page in the App application requests to access a server address corresponding to the current mobile phone network environment, and Hosts cannot be switched to access other environments like a PC. In the prior art, in order to solve the above problems, a proxy tool similar to Charles and the like is used, and a proxy of an Android real machine in the same local area network environment as a PC is configured, all network requests of the Android real machine are proxied to a local PC, and then Hosts are modified at the local PC, so that all requests on the Android real machine access other switched environments from local through DNS resolution.
Disclosure of Invention
The embodiment of the application aims to provide a mixed-mode mobile application debugging system, so as to solve the problems of high cost and complex configuration when a mode of agent tools such as Charles and the like is adopted to carry out front-end and back-end joint debugging on Hybrid application.
One aspect of the embodiments of the present application provides a mixed mode mobile application debugging system, where the debugging system includes a debugging device, a server, a node server, and a device to be debugged for installing a mixed mode mobile application to be debugged, and a desktop client and a local project debugging service are installed in the debugging device, where:
the local project debugging service is used for packaging the page codes of the mixed mode mobile application to be debugged to generate a page code file directory;
the local project debugging Service is also used for adding a code segment for loading a script of a Service Worker in a preset file in the page code file directory;
the desktop client is used for packaging a page code file directory containing the script of the Service Worker to generate a page code file packet and uploading the page code file packet to the node server;
the node server is used for decompressing the page code file packet to generate a first code file and deploying the generated first code file to 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 also used for loading the script of the Service Worker according to the code segment in the first code file, intercepting the network request of the page to be debugged through the script of the Service Worker, and modifying the request address of the intercepted network request into the API (application programming interface) Service address of the node server;
the node server is used for forwarding the network request to the desktop client after receiving the network request;
the desktop client is used for performing domain name resolution on the network request and sending the network request to the server according to the address obtained after resolution;
and the server is used for responding to the network request.
Optionally, the desktop client is an Electron desktop client, wherein:
the Electron desktop client is used for creating a local project packaging service and a WebSocket client;
the Electron desktop client is further used for establishing a WebSocket long connection with the node server through the WebSocket client and starting the local project debugging service through the local project packaging service;
and the node server is also used for sending the network request to the WebSocket client through the WebSocket long connection.
Optionally, the page code file directory includes an html file, a css file, and a js file, and the local project debugging Service is further configured to add a code segment for loading a script of a Service Worker in the html file.
Optionally, the server is further configured to return a response result responding to the network request to the Electron desktop client;
the Electron desktop client is further used for packaging the received response result and sending the packaged first response result to the node server through the WebSocket client;
the node server is further configured to parse the received first response result, and return a second response result obtained after parsing to the Service Worker, so that the Service Worker uses the second response result as a response result of the network request of the page to be debugged.
Optionally, the Electron desktop client is further configured to request the node server to obtain session credential information;
and the node server is used for generating session voucher information when receiving a session voucher information acquisition request sent by the Electron desktop client, and sending the session voucher information to the Electron desktop client so that the WebSocket client establishes WebSocket long connection with the node server according to the session voucher information.
Optionally, the node server is further configured to create a directory named by the session credential information in the static resource service after the session credential information is generated.
Optionally, the node server is further configured to decompress the received page code file package and deploy the decompressed page code file package to the directory.
Optionally, the node server is further configured to, after receiving the network request through the API interface service address, parse the network request, and encapsulate the parsed first network request into a second network request including a request sequence number, a request address, a request mode, a request header, and a request body.
Optionally, the Electron desktop client is further configured to encapsulate the received first response result into a second response result including a response sequence number, a response status code, response status information, a response header, and a response body.
The application also provides a mixed-mode mobile application debugging method, which is applied to a mixed-mode mobile application debugging system comprising debugging equipment, a server, a node server and equipment to be debugged, wherein the equipment to be debugged is provided with a desktop client and local project debugging service, and the method comprises the following steps:
packaging the page codes of the mixed mode mobile application to be debugged through the local project debugging service to generate a page code file directory;
adding a code segment for loading a script of a Service Worker in a preset file in the page code file directory through the local project debugging Service;
packaging a page code file directory containing the script of the Service Worker to generate a page code file packet through the desktop client, and uploading the page code file packet to the node server;
decompressing the page code file packet 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;
loading the script of the Service Worker according to the code segment in the first code file through the mixed-mode mobile application, intercepting the network request of the page to be debugged through the script of the Service Worker, and modifying the request address of the intercepted network request into the API Service address of the node server;
after receiving the network request, the node server forwards the network request to the desktop client;
performing domain name resolution on the network request through the desktop client, and sending the network request to the server according to an address obtained after resolution;
and responding to the network request through the server-side server.
According to the mixed-mode mobile application debugging system provided by the embodiment of the application, after local projects are packaged and uploaded by using an Electron desktop client, static resources of the projects are loaded by an Android real machine, all HTTP/HTTPS network requests in a Hybrid page are transmitted to a local PC layer by layer through a Service Worker and the like, the requests are transmitted to a server side server of a non-online environment such as a test environment and a PRE environment through local DNS analysis, and the effect of front-end and back-end joint debugging of the test environment is obtained. The debugging system in the application enables a front-end developer not to care how to forward, and does not need to perform network request hijacking by means of tools such as an agent, so that the configuration complexity can be reduced, all network requests in a Hybrid page are analyzed and requested to be forwarded through a local DNS, the server interface service under the test and PRE environment is directly accessed, and the local Host is realized.
Drawings
FIG. 1 is a schematic diagram illustrating an environment in which a mixed-mode mobile application debugging system according to an embodiment of the present application may be implemented;
FIG. 2 schematically illustrates a block diagram of a mixed-mode mobile application debugging system according to an embodiment of the present application;
fig. 3 schematically shows a flowchart of a mixed-mode mobile application debugging method according to an embodiment of the present application.
Detailed Description
The advantages of the present application are further illustrated below with reference to the accompanying drawings and specific embodiments.
Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like numbers in different drawings represent the same or similar elements unless otherwise indicated. The implementations described in the exemplary embodiments below are not intended to represent all implementations consistent with the present disclosure. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the present disclosure, as detailed in the appended 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 and all possible combinations of one or more of the associated listed items.
It is to be understood that although the terms first, second, third, etc. may be used herein to describe various information, such 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 "when … …" or "in response 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 of performing the steps, but merely serve to facilitate the description of the present application and to distinguish each step, and therefore should not be construed as limiting the present application.
Fig. 1 schematically illustrates an application environment diagram of a mixed-mode mobile application debugging system according to an embodiment of the present application. In an exemplary embodiment, the system of the application environment may include a terminal device 10, a device 20 that installs a mixed-mode mobile application to be debugged, and a server 30. The terminal device 10, the device 20 installed with the mixed-mode mobile application to be debugged, and the server 30 form a wireless or wired connection therebetween. 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 handset, an android tablet, or an iOS simulator, for example. The server 30 may be a server or a server cluster composed of a plurality of servers, or a cloud computing center. The server 30 is used to store page code of a 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 this embodiment includes a debugging device 200, a device to be debugged 201 for installing a mixed mobile application to be debugged, a node server 202, and a server 203, where a local project debugging service and a desktop client are installed in the debugging device 200, where:
the desktop client is configured to upload a page code of the 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 a mixed-mode mobile application debugging system. In this embodiment, before debugging a mixed-mode mobile application (Hybrid application), a page code of the mixed-mode mobile application needs to be uploaded to the node server 202 through a desktop client in the debugging device 200.
In an exemplary embodiment, the desktop client is an Electron desktop client, and the debugging apparatus 200 further includes a local project debugging service installed in the debugging apparatus 200.
The Electron desktop client is a MacOS and Windows desktop client based on an Electron open source framework, is a debugging coupling middle layer capable of realizing debugging among a PC (computer), a node server 202, a real machine (Android mobile phone) or an emulator (iOS emulator), is a UI access layer of a desktop client user, and integrates multiple functions of a PC bottom layer system, WebSocket communication, Chromium kernel control and the like. Specifically, the Electron desktop client can implement AppleScript automation service and node-sim iOS simulator automation service, and implement automation processes of all relevant links of a page HMR (hot module replacement), including injection configuration, bridging intermediate layer, and the like.
In this embodiment, after the Electron desktop client 200 is started, it creates a WebSocket client and a WebSocket server locally on the PC.
The WebSocket client may actively initiate a connection request to the node server 202 to establish a first WebSocket long connection therebetween, and may forward data acquired from the node server 202 to the WebSocket client through the first WebSocket long connection. The WebSocket client also forwards 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, in order to avoid that a device without authority is also connected 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 Electron desktop client, and send the session credential information to the Electron 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 session credential information acquisition request, the node server 202 may randomly generate the session credential information, where the session credential information is a credential for establishing a connection with the node server 202, and only a device having the session credential may establish a connection with the node server 202.
The WebSocket server serves as a data transfer station for transmitting relevant data by using debugging data of a page to be debugged, HMR hot updating data of the page to be debugged and a Service Worker hijack request. The WebSocket server can be connected with a debugging tool (for example, a Chrome devices front debugging tool), and realizes communication between the node server 202 and the Chrome devices front debugging tool, the Webpack Service, the Hybrid application (mixed mode mobile application), the page to be debugged, and the Service Worker.
In this embodiment, after the Electron 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 an Electron desktop client, and is used for communicating with the module hot-replacement server to realize the exchange of the JSON data for HMR hot-update.
In this embodiment, in order to process the page code in time by the local project debugging service, after the Electron 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 by the local project packaging service.
Specifically, the local project packaging service is a Webpack development server created by a subprocess of an Electron client, and is used for executing starting of the local project debugging service, so that the local project debugging service processes page codes.
In this embodiment, the Electron desktop client is further configured to add, through the local project packaging service, a first script for creating a second module hot-replacement client and a second script for creating a module hot-replacement server in the page code.
Specifically, the module hot-replacement server is a WebSocket server locally created by Webpack when Webpack opens the DevServer mode, and is used for the first module hot-replacement client to connect and provide HMR hot-update JSON data.
The first script is a JavaScript script and is used for replacing a built-in module hot replacement client of the Webpack, and by adding the first script into a page code, a WebSocket long connection is established with a built-in module hot replacement server of the Webpack when the page code is loaded, so that JSON data of HMR hot update can be exchanged. In this embodiment, the second module hot-replacement client created through the first script may change a target address of the default WebSocket long connection for HMR hot-update of the page to be debugged to be an address of the node server 202, so as to forward JSON data for HMR hot-update to the node server 202.
The Webpack is a module packager and mainly aims to package JavaScript code files running on a browser.
It should be noted that the HMR hot update, i.e. module hot replacement, is a function that can replace, add or delete a module during the running of an application program without reloading the whole page. It has the following characteristics:
1. the page state is preserved (the page state includes the states of form, route, etc.).
2. Only the changed content is updated, and the packaging, page loading and page presenting speeds are higher, so that precious development time is saved.
3. When the CSS/JS generates a modification in the source code, the update is done immediately in the browser, which is almost equivalent to changing the style directly in the browser devtools.
The second script is also a JavaScript script which can be used for replacing a built-in module hot-replacement server of the Webpack, and specifically, the JavaScript script core is that a serverPath path of the built-in module hot-replacement server is changed into a self-defined path, so that a WebSocket long connection can be established with the built module hot-replacement client.
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 analyzed to obtain a gitgnore configuration and a git file configuration, the first script and the second script are added to the configuration file obtained after the analysis, 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 package service completes adding the first script and the second script in the page code, the local project debugging service may create a module hot replacement service end according to the second script.
The local project debugging service can also pack the page codes containing the first script to generate a page code file directory.
Wherein, the local project debugging service is a Dev running service of a Webpack-based local front-end project.
The page code file directory refers to a dist file, which includes a plurality of files, for example, the dist file contains 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 of a third script used for loading a Service Worker 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 adopts JavaScript to control a related 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 Worker context, i.e. in other threads, not the browser main thread, and therefore cannot access the page DOM and does not cause blocking, can only be carried by HTTPS, and is a thread completely asynchronous to 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 Worker when the page to be debugged is loaded, the modification of the network request and the response result is implemented, and then the modified network request and the response result are returned to the current page to be debugged as the network request result of the current page to be debugged. In this embodiment, a code segment for loading a Service Worker 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 Worker, so as to take over a current page to be debugged.
In this embodiment, the preset file is a preset file for adding code segments, and is specifically an html file in a target page code file.
In this embodiment, after the code segment is added, a third script of the JavaScript of the Service Worker may be placed under the page code file directory, so that the script of the Service Worker may be packaged together with other static resource files in the page code file directory by the Electron 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 page code file directory including the third script may be packaged into a tar packet by the Electron desktop client, so that the Electron desktop client may upload the tar packet to the node server 202 by means of an HTTP request, and specifically, the Electron desktop client may place the tar packet into a request 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 debugging device 201.
Specifically, the node server 202 may be deployed in a public network environment, and is configured to carry API interface services, manage WebSocket long connection data interaction, and be responsible for receiving, decompressing, managing Session credentials (Session ids) and project static resources of different clients, providing static resource services, and the like. The static resource service is a container in the node server 202 for storing page code.
In this embodiment, after receiving the page code uploaded by the debugging device 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 debugging device 201.
In an exemplary embodiment, when the page code received by the node server 202 is a page code file packet generated by packaging through an Electron desktop client, the node server 202 is further configured to decompress the page code file packet to generate a first code file, deploy the generated first code file to the static resource service, and return the network address of the static resource service to the Electron desktop client.
It can be understood that, when the page code received by the node server 202 exists in the form of a file package, the page code file package needs to be decompressed first, and then the decompressed first code file is deployed into 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 by 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 subsequently deployed, the received page code file packet may be decompressed, and the decompressed page code may be deployed in the directory named by 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 first obtains the network address from the debugging device 201, so that the page code can be obtained and loaded from the static resource server according to the network address, and the page to be debugged is opened.
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 a process of remotely debugging the device to be debugged 203. In this embodiment, during debugging, after the page to be debugged is opened, the debugging tool can directly perform remote page debugging on the page to be debugged. The page debugging may include page debugging operations such as an audit element, Console printing, Network view, 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 tool comprises a Chrome Dettools front debugging tool, the Chrome Dettools front debugging tool is used for page debugging based on a Chrome Dettools Protocol cross-end debugging Protocol, the Protocol is used for page debugging data interaction based on JSON format data, equipment limitation is avoided, and most mainstream browsers and Webviews based on Chrome and Blink kernels in the market can be used for realizing cross-end debugging.
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.
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 a network address returned by the node server 202 after receiving the network address, 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 may be scanned to acquire the network address from the barcode, and then the first code file is acquired from a static resource service according to the network address and loaded to open the page to be debugged.
In an embodiment, in order to facilitate the subsequent mixed-mode mobile application to establish a WebSocket long connection with the node server 202, the Electron desktop client may further splice session credential information and the network address, and generate a corresponding identification code according to character information obtained after 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 the 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, the acquired first page code includes a code segment for loading the third script (the script of the Service Worker), so that the script of the Service Worker can be loaded simultaneously in the process of loading the acquired first page code file, and the network request of the page to be debugged is intercepted by the Service Worker, so that the request address of the intercepted network request can be modified to the API 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 analyzes the domain name of the network request through the Electron desktop client, and sends the network request to a server according to the address obtained after analysis. The server may respond to the network request after receiving the network request.
The server is a server that deploys API interface services, and is usually deployed in various environments, such as testing, PRE, and formal environments, and used for front-end and back-end joint debugging at different stages.
In an exemplary embodiment, after the node server 202 receives the network request through the API service address, the node server parses the network request, and encapsulates the parsed first network request 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 implementation manner, 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 receiving a response result returned by the server, the Electron desktop client may package the response result, and send the packaged first response result to the node server 202 through the WebSocket client; then, the node server 202 may analyze the received first response result, and return a second response result obtained after the analysis to the Service Worker, so that the Service Worker uses the second response result as a response result of the network request included in the page to be debugged.
In an embodiment, in order to facilitate analysis of the response result, after the Electron desktop client receives the first response result, the Electron desktop client encapsulates the received first response result into a second response result including a response serial number, a response status code, response status information, a response header, and a response body.
And the second module hot-replacement client is used for establishing a second WebSocket long connection with the node server.
Specifically, the second module hot-replacement client is a WebSocket client created when the first page code file is loaded, and is used for establishing a WebSocket long connection with the module hot-replacement server and exchanging HMR hot-update JSON data. In this embodiment, after receiving the JSON data of the HMR hot update, the second module hot-replacement client actively loads the packed hot module file to replace the local module in the page to be debugged, thereby achieving 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 chrome kernel to create a Unix Domain Socket server according to the Webview debugging mode.
Specifically, the Webview debugging mode is a mode for remotely debugging an application. The Unix Domain Socket service end is a service for providing JSON data for external connection, communication and exchange of Hybrid page debugging, the process ID format of the Unix Domain Socket service end is @ Webview _ devtools _ remote _ $ { pid }, and the pid is Webview process ID. When the Unix Domain Socket server communicates with the Hybrid application, an Inter-Process-Communication (IPC) Communication mode which is based on a file system and does not need to be transmitted through a network is adopted, and the Communication mode does not need to be subjected to processes of network packing, verification, unpacking and the like, so that the Unix Domain Socket server is more reliable and has higher efficiency.
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 establishing the fourth WebSocket long connection with the node server 202, the mixed-mode mobile application may first identify session credential information from the identification code, and then establish the fourth WebSocket long connection with the node server 202 by means of the session credential information, so that the debugging JSON data of the page to be debugged may be exchanged with 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 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 upgrading instruction to the Unix Domain Socket server after the 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 mixed-mode mobile application may use a localcocket library to find a process corresponding to a 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 the handshake is successful to upgrade a current communication protocol to a WebSocket protocol. After the upgrade is successful, the mixed-mode mobile application can perform corresponding message communication with a Unix Domain Socket Server Server based on a Websocket protocol.
The desktop client is also used for opening the desktop mode adjusting window;
and the desktop debugging 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 debugging window through the WebSocket client, and load a debugging tool (e.g., the Chrome developers front debugging tool) installed in the debugging device in the desktop debugging window to debug the page to be debugged.
Specifically, the Chrome devtols Frontend debugging tool is used for debugging a front end UI of a page, can be separated from a 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 Chrome built-in devtols.
The Chrome Dettools front debugging tool is used for establishing a fifth WebSocket long connection with the WebSocket server so as to exchange debugging data with the Chrome kernel through the fifth WebSocket long connection to debug the page to be debugged.
Specifically, when establishing a fifth WebSocket long connection with the WebSocket server, the Chrome Devtools front debugging tool may first acquire address information of the WebSocket server through the WebSocket client, and then may establish the WebSocket long connection with the WebSocket server according to the acquired address information of the WebSocket server.
In an embodiment, when the Chrome devtols fronted debugging tool realizes debugging of the page to be debugged through the fifth WebSocket long connection, the 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 first WebSocket long connection channel, the fourth WebSocket long connection channel, and the third WebSocket long connection channel in sequence, thereby realizing debugging of the page to be debugged.
In another embodiment, when the debugging tool implements debugging on the page to be debugged through the fifth WebSocket long connection, the debugging tool may further send a debugging information acquisition request of the Hybrid page to be debugged to the WebSocket server through the fifth WebSocket long connection, so that the WebSocket server may send the debugging information acquisition request to the Unix Domain Socket server sequentially through the WebSocket client, the first WebSocket long connection channel, the fourth WebSocket long connection channel, and the third WebSocket long connection channel, thereby implementing acquisition of the debugging information of the page to be debugged from the Unix Domain Socket server and debugging operation according to the acquired debugging 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 through a fourth WebSocket long connection after the fourth WebSocket long connection is established with the node server 202, a signal that a debugging channel of the page to be debugged is opened; 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 debugging window after receiving the signal.
In this embodiment, the desktop debugging window is opened only when a signal that the debugging channel is opened is received, so as to formally start page debugging on the page to be debugged.
The node server 202 is further configured to notify, through the first WebSocket long connection, the Electron desktop client to establish a sixth WebSocket long connection between the first module hot-swap client and the module hot-swap server after the second WebSocket long connection is established, so as to implement hot-swap of a 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 of establishing 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 for page hot-swap to the module hot-swap server sequentially 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, thereby achieving acquisition of the data for page hot-swap.
In an exemplary embodiment, after the page code is modified, the Electron desktop client may further send the modified page code to the second module hot-swap client through the module hot-swap server side sequentially through the channel connected by the sixth WebSocket long link, the channel connected by the first WebSocket long link, and the channel connected by the second WebSocket long link, so as to implement hot-swap of the page according to the modified page code by the second module hot-swap client.
In an exemplary embodiment, the device to be debugged 201 further includes an iOS simulator, and the debugging tool further includes a Safari browser, where:
the Electron desktop client is also used for creating AppleScript automation services and iOS simulator automation services.
Specifically, AppleScript is a scripting language created by apple inc, is suitable for 7.1 and higher versions of MacOS, allows a user to directly control a scriptable 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 using the AppleScript script in the MacOS, such as a system event, a Safari browser, an iOS Simulator, and the like.
The iOS simulator automation service is used for executing an xcrun simctl command by using a node-simctl three-party library to control the iOS simulator, and comprises services of starting and closing the simulator, installing an App, opening a URL and the like.
The xcrun is a command line tool provided by an Xcode application under the MacOS, and is used for controlling the function related to the Xcode development.
The simctl is a sub-command of the xcrun tool for controlling the simulator, and provides the functions of starting, closing, installing an application, opening a URL, and the like of the simulator.
The Node-simctl is a Node version three-way library of simctl tools provided by the Appium for controlling the iOS Simulator in the Node program.
The Electron 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 a real iOS device, in this embodiment, in order to save time required in a debugging process, the iOS simulator is automatically started through an iOS simulator automation service, the mixed-mode mobile application is installed through the iOS simulator automation service after the iOS simulator is started, and the network address is opened 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 is automatically installed in the iOS simulator, and the page to be debugged is opened through the mixed-mode mobile application.
The wkbwebview kernel is a core part of modern WebKit API in iOS 8 and OS X Yosemite applications. It replaces UIWebView in UIKit and WebView in AppKit, providing a unified cross-dual platform API (iOS and OS).
In an exemplary embodiment, in order to avoid that a plurality of iOS simulators are turned on at the same time, in this embodiment, when the iOS simulators are turned on by the iOS simulator automation service, the Electron desktop client may first turn off all currently turned on iOS simulators by the iOS simulator automation service, and after all iOS simulators are turned off, turn on a default or user-selected iOS simulator again. Thereafter, the mixed-mode mobile application may be installed by the iOS simulator automation service.
In an exemplary embodiment, after completing installation of the mixed-mode mobile application, the Electron desktop client may further install a test environment certificate (e.g., an SSL certificate) through the iOS emulator automation service, so that the mixed-mode mobile application may access an HTTPS service of a test environment.
In an exemplary embodiment, after the Electron 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 a URL Schema, so that the mixed-mode mobile application may call a wkbwebview kernel to load the page to be debugged.
The URL Schema is supported by most APPs at present, and has a function of calling the APPs and opening corresponding pages when a browser in a real machine opens a URL.
From iOS 8, WKWebview replaces UIWebview gradually and becomes Webview mainly used by iOS App, and the WKWebview is based on Webkit kernel.
In an exemplary embodiment, the invoking, by the mixed-mode mobile application, the wkbwebview kernel to load the page to be debugged includes: and the mixed-mode mobile application calls the WKWebview kernel to start WKWebview kernel debugging service, and calls the WKWebview kernel to render the page to be debugged by adopting a Webkit engine.
Specifically, the wkbev kernel debugging service is a Webview debugging service in which a wkbev kernel is locally turned on, and is similar to a chrome kernel debugging service of Android. However, due to the limitation of the iOS, under a conventional condition, a third-party application cannot control the rendering and the internal debugging of the wkbev, and cannot contact the wkbev kernel debugging service, 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 renders the page to be debugged by adopting a Webkit engine.
The Electron desktop client is also used for opening a Safari developer tool from the Safari browser through an AppleScript automation service.
Specifically, the Electron 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 real machine or simulator, is similar to Chrome developers tools, 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 debugging of a page to be debugged through the connection channel.
Specifically, after the Safari developer tool and the WKWebview kernel debugging service of the iOS simulator establish a connection channel, page debugging data can be exchanged based on Webkit-like debugging protocol communication, and complete functional page debugging is performed.
The mixed-mode mobile application debugging system can enable front-end developers to directly carry out remote debugging on Hybrid pages on Android 4.4 and various Android real machines by using Chrome Dettools Frontend debugging tools in a desktop debugging window opened by an Electron desktop client, obtain debugging effects similar to debugging PC pages by using Chrome built-in developer tools, and does not need to use Charles agents, USB hardware equipment connection and the like, so that the cost and the complexity can be reduced.
Referring to fig. 3, a method for debugging a mixed-mode mobile application according to an embodiment of the present application is shown. The method is applied to a mixed-mode mobile application debugging system which comprises debugging equipment, a server, a node server and equipment to be debugged, wherein the equipment to be debugged is provided with a desktop client and a local project debugging service, and the mixed-mode mobile application debugging system is the mixed-mode mobile application debugging system in the embodiment and is not described in detail in the embodiment.
In this embodiment, the method includes:
step S30, packaging the page code of the mixed mode mobile application to be debugged through the local project debugging service to generate a page code file directory;
step S31, adding a code segment for loading a script of a Service Worker in a preset file in the page code file directory through the local project debugging Service;
step S32, packing a page code file directory containing the script of the Service Worker through the desktop client to generate a page code file packet, and uploading the page code file packet to the node server;
step S33, decompressing the page code file packet through the node server to generate a first code file, and deploying the generated first code file to the static resource service;
step S34, 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 S35, loading the script of the Service Worker according to the code segment in the first code file through the mixed mode mobile application, intercepting the network request of the page to be debugged through the script of the Service Worker, and modifying the request address of the intercepted network request into the API Service address of the node server;
step S36, after receiving the network request, the node server forwards the network request to the desktop client;
step S37, performing domain name resolution on the network request through the desktop client, and sending the network request to the server according to the address obtained after resolution;
and step S38, responding to the network request through the server side server.
According to the mixed-mode mobile application debugging method, a front-end developer can directly carry out remote debugging on Hybrid pages on Android 4.4 and various Android real machines by using a Chrome Dettools Frontend debugging tool in a desktop debugging window opened by an Electron desktop client, the debugging effect similar to that of debugging a PC page by using a Chrome built-in developer tool is obtained, and Charles proxy, USB hardware equipment connection and the like are not needed, so that the cost and the complexity can be reduced.
The above-described embodiments of the apparatus are merely illustrative, and the units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on at least two network units. Some or all of the modules can be screened out according to actual needs to achieve the purpose of the scheme of the embodiment of the application. One of ordinary skill in the art can understand and implement it without inventive effort.
Through the above description of the embodiments, those skilled in the art will clearly understand that each embodiment can be implemented by software plus a general hardware platform, and certainly can also be implemented by hardware. It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by hardware related to instructions of a computer program, which can be stored in a computer readable storage medium, and when executed, can include the processes of 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 (RAM), or the like.
Finally, it should be noted that: the above embodiments are only used for illustrating the technical solutions of the present application, and not for limiting the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; and the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present application.
Claims (10)
1. A mixed-mode mobile application debugging system, characterized in that the debugging system comprises a debugging device, a server, a node server and a device to be debugged for installing a mixed-mode mobile application to be debugged, the debugging device having a desktop client and a local project debugging service installed therein, wherein:
the local project debugging service is used for packaging the page codes of the mixed mode mobile application to be debugged to generate a page code file directory;
the local project debugging Service is also used for adding a code segment for loading a script of a Service Worker in a preset file in the page code file directory;
the desktop client is used for packaging a page code file directory containing the script of the Service Worker to generate a page code file packet and uploading the page code file packet to the node server;
the node server is used for decompressing the page code file packet to generate a first code file and deploying the generated first code file to 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 also used for loading the script of the Service Worker according to the code segment in the first code file, intercepting the network request of the page to be debugged through the script of the Service Worker, and modifying the request address of the intercepted network request into the API (application programming interface) Service address of the node server;
the node server is used for forwarding the network request to the desktop client after receiving the network request;
the desktop client is used for performing domain name resolution on the network request and sending the network request to the server according to the address obtained after resolution;
and the server is used for responding to the network request.
2. The mixed-mode mobile application debugging system of claim 1, wherein the desktop client is an Electron desktop client, wherein:
the Electron desktop client is used for creating a local project packaging service and a WebSocket client;
the Electron desktop client is further used for establishing a WebSocket long connection with the node server through the WebSocket client and starting the local project debugging service through the local project packaging service;
and the node server is also used for sending the network request to the WebSocket client through the WebSocket long connection.
3. The mixed-mode mobile application debugging system of claim 2, wherein the page code file directory comprises an html file, a css file, and a js file, and wherein the local project debugging Service is further configured to add a code segment for loading a script of a Service Worker into the html file.
4. The mixed-mode mobile application debugging system of claim 2, wherein the server is further configured to return a response result in response to the network request to the Electron desktop client;
the Electron desktop client is further used for packaging the received response result and sending the packaged first response result to the node server through the WebSocket client;
the node server is further configured to parse the received first response result, and return a second response result obtained after parsing to the Service Worker, so that the Service Worker uses the second response result as a response result of the network request of the page to be debugged.
5. The mixed-mode mobile application debugging system of claim 2, wherein the Electron desktop client is further configured to request session credential information from the node server;
and the node server is used for generating session voucher information when receiving a session voucher information acquisition request sent by the Electron desktop client, and sending the session voucher information to the Electron desktop client so that the WebSocket client establishes WebSocket long connection with the node server according to the session voucher information.
6. The mixed-mode mobile application debugging system of claim 5, wherein the node server is further configured to create a directory named by the session credential information in the static resource service after generating the session credential information.
7. The mixed-mode mobile application debugging system of claim 5, wherein the node server is further configured to decompress and deploy the received package of page code files into the directory.
8. The mixed-mode mobile application debugging system of claim 2, wherein the node server is further configured to parse the network request after receiving the network request through the API service address, and encapsulate the parsed first network request into a second network request including a request sequence number, a request address, a request type, a request header, and a request body.
9. The mixed-mode mobile application debugging system of claim 4, wherein the Electron desktop client is further configured to encapsulate the received first response result into a second response result comprising a response sequence number, a response status code, response status information, a response header, and a response body.
10. A mixed mode mobile application debugging method is applied to a mixed mode mobile application debugging system which comprises debugging equipment, a server, a node server and equipment to be debugged and is provided with mixed mode mobile application to be debugged, wherein a desktop client and local project debugging service are arranged in the debugging equipment, and the method is characterized by comprising the following steps:
packaging the page codes of the mixed mode mobile application to be debugged through the local project debugging service to generate a page code file directory;
adding a code segment for loading a script of a Service Worker in a preset file in the page code file directory through the local project debugging Service;
packaging a page code file directory containing the script of the Service Worker to generate a page code file packet through the desktop client, and uploading the page code file packet to the node server;
decompressing the page code file packet 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;
loading the script of the Service Worker according to the code segment in the first code file through the mixed-mode mobile application, intercepting the network request of the page to be debugged through the script of the Service Worker, and modifying the request address of the intercepted network request into the API Service address of the node server;
after receiving the network request, the node server forwards the network request to the desktop client;
performing domain name resolution on the network request through the desktop client, and sending the network request to the server according to an address obtained after resolution;
and responding to the network request through the server-side server.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110920806.2A CN113641581B (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 |
|---|---|---|---|
| CN202110920806.2A CN113641581B (en) | 2021-08-11 | 2021-08-11 | Mixed mode mobile application debugging method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113641581A true CN113641581A (en) | 2021-11-12 |
| CN113641581B CN113641581B (en) | 2023-10-20 |
Family
ID=78420885
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110920806.2A Active CN113641581B (en) | 2021-08-11 | 2021-08-11 | Mixed mode mobile application debugging method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113641581B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116319794A (en) * | 2023-04-18 | 2023-06-23 | 安元科技股份有限公司 | Method and system for solving project communication under cloud system and complex network |
| CN117472784A (en) * | 2023-12-25 | 2024-01-30 | 图灵人工智能研究院（南京）有限公司 | Browser-based Serverless code online debugging method |
Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR20140019623A (en) * | 2012-08-06 | 2014-02-17 | 인크로스 주식회사 | An integrated platform for authoring web applications and the authoring method thereof |
| CN106126420A (en) * | 2016-06-21 | 2016-11-16 | 北京小米移动软件有限公司 | Application program adjustment method and device |
| US9645910B1 (en) * | 2015-03-12 | 2017-05-09 | Amazon Technologies, Inc. | Cross platform mobile HTML debugging |
| US9652364B1 (en) * | 2015-03-12 | 2017-05-16 | Amazon Technologies, Inc. | Cloud service for mobile testing and debugging |
| CN106970790A (en) * | 2017-03-09 | 2017-07-21 | 腾讯科技（深圳）有限公司 | Method, relevant device and system that a kind of application program is created |
| CN107861875A (en) * | 2017-11-15 | 2018-03-30 | 北京中电普华信息技术有限公司 | A kind of analogy method and system for mixing Mobile solution |
| CN109800173A (en) * | 2019-01-28 | 2019-05-24 | 腾讯科技（深圳）有限公司 | Program debugging method, device and storage medium |
| CN110597709A (en) * | 2019-08-13 | 2019-12-20 | 平安国际智慧城市科技股份有限公司 | Interactive debugging method and device for mixed-mode mobile application and computer equipment |
| CN111338961A (en) * | 2020-02-28 | 2020-06-26 | 北京小米移动软件有限公司 | Application debugging method and device, electronic equipment and storage medium |
| 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 |
| CN112579448A (en) * | 2020-12-10 | 2021-03-30 | 平安普惠企业管理有限公司 | Debugging method and system for hybrid application |
-
2021
- 2021-08-11 CN CN202110920806.2A patent/CN113641581B/en active Active
Patent Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR20140019623A (en) * | 2012-08-06 | 2014-02-17 | 인크로스 주식회사 | An integrated platform for authoring web applications and the authoring method thereof |
| US9645910B1 (en) * | 2015-03-12 | 2017-05-09 | Amazon Technologies, Inc. | Cross platform mobile HTML debugging |
| US9652364B1 (en) * | 2015-03-12 | 2017-05-16 | Amazon Technologies, Inc. | Cloud service for mobile testing and debugging |
| CN106126420A (en) * | 2016-06-21 | 2016-11-16 | 北京小米移动软件有限公司 | Application program adjustment method and device |
| CN106970790A (en) * | 2017-03-09 | 2017-07-21 | 腾讯科技（深圳）有限公司 | Method, relevant device and system that a kind of application program is created |
| CN107861875A (en) * | 2017-11-15 | 2018-03-30 | 北京中电普华信息技术有限公司 | A kind of analogy method and system for mixing Mobile solution |
| CN109800173A (en) * | 2019-01-28 | 2019-05-24 | 腾讯科技（深圳）有限公司 | Program debugging method, device and storage medium |
| WO2020177519A1 (en) * | 2019-03-05 | 2020-09-10 | 中国银联股份有限公司 | Debugging method executed on smart terminal and software debugging device |
| CN110597709A (en) * | 2019-08-13 | 2019-12-20 | 平安国际智慧城市科技股份有限公司 | Interactive debugging method and device for mixed-mode mobile application and computer equipment |
| CN111338961A (en) * | 2020-02-28 | 2020-06-26 | 北京小米移动软件有限公司 | Application debugging method and device, electronic equipment and storage medium |
| CN111352847A (en) * | 2020-03-09 | 2020-06-30 | 中国邮政储蓄银行股份有限公司 | Real-time debugging method and system for mobile application terminal |
| CN112579448A (en) * | 2020-12-10 | 2021-03-30 | 平安普惠企业管理有限公司 | Debugging method and system for hybrid application |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116319794A (en) * | 2023-04-18 | 2023-06-23 | 安元科技股份有限公司 | Method and system for solving project communication under cloud system and complex network |
| CN116319794B (en) * | 2023-04-18 | 2023-10-24 | 安元科技股份有限公司 | Method and system for solving project communication under cloud system and complex network |
| CN117472784A (en) * | 2023-12-25 | 2024-01-30 | 图灵人工智能研究院（南京）有限公司 | Browser-based Serverless code online debugging method |
| CN117472784B (en) * | 2023-12-25 | 2024-03-19 | 图灵人工智能研究院（南京）有限公司 | Browser-based Serverless code online debugging method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113641581B (en) | 2023-10-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106776313B (en) | Method and device for simulating service and centralized management platform | |
| CN106844137B (en) | Server monitoring method and device | |
| US10990369B2 (en) | Repurposing serverless application copies | |
| CN113641582A (en) | Mixed-mode mobile application debugging method and system | |
| US11513789B2 (en) | Application deployment method, apparatus, and system | |
| US20090082008A1 (en) | Mobile Phone Code Debugging Method and Apparatus | |
| CN111159614B (en) | Webpage resource acquisition method and device | |
| CN113641581B (en) | Mixed mode mobile application debugging method and system | |
| CN112732572A (en) | Service testing method, device and system, storage medium and electronic device | |
| CN109800173A (en) | Program debugging method, device and storage medium | |
| CN111708702A (en) | Simulation test method, client, server, system and readable storage medium | |
| US11726800B2 (en) | Remote component loader | |
| CN112615759B (en) | Full link voltage measurement assembly, full link voltage measurement method and device | |
| CN107181779A (en) | Processing method, the device and system of access request | |
| CN111367685B (en) | Interface calling method and device, computer equipment and storage medium | |
| CN108345606A (en) | The acquisition methods and device of web page resources | |
| CN112231209A (en) | Parameter acquisition method and device, computer equipment and storage medium | |
| CN113641580B (en) | Mixed mode mobile application debugging method and system | |
| CN113626330A (en) | Mixed-mode mobile application debugging method and system | |
| US20200210327A1 (en) | M2m application test device and method | |
| CN104917633A (en) | Method and device simulating FOTA upgrade | |
| CN114915565B (en) | Network debugging method and system | |
| CN110674435A (en) | Page access method, server, terminal, electronic equipment and readable storage medium | |
| CN113626329A (en) | Mixed-mode mobile application debugging system | |
| Lanui et al. | A cloud-based solution for testing applications' compatibility and portability on fragmented Android platform |
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 |