WO2023109202A1

WO2023109202A1 - Applet plugin debugging method and system, and computer readable storage medium

Info

Publication number: WO2023109202A1
Application number: PCT/CN2022/117422
Authority: WO
Inventors: 张聪萍; 解楠; 沈玺
Original assignee: 中国银联股份有限公司
Priority date: 2021-12-17
Filing date: 2022-09-07
Publication date: 2023-06-22
Also published as: CN114328197A

Abstract

An applet plugin debugging method, comprising: when a target applet calls an applet plugin to be debugged, an application sending a first plugin debugging protocol packet to a debugging tool main process, wherein the target applet runs in an applet container starting a debugging function in the application; when a real device debugging window is switched to a target debugging panel, the real device debugging window obtaining the first plugin debugging protocol packet from the debugging tool main process, analyzing applet plugin calling information, and displaying same on the target debugging panel; when the real device debugging window initiates a plugin debugging operation for the target debugging panel, the real device debugging window pushing a second plugin debugging protocol packet to the application by means of a pre-established bidirectional communication channel; and the application entering a plugin debugging mode in response to the second plugin debugging protocol packet. By means of the method, more comprehensive and real plugin debugging can be provided.

Description

A small program plug-in debugging method, system and computer-readable storage medium

This application claims the priority of the Chinese patent application with application number 202111553679.3 and titled "A Small Program Plug-in Debugging Method, Device, and Computer-Readable Storage Medium" filed on December 17, 2021. The Chinese patent application The disclosure is incorporated herein by reference.

technical field

The invention belongs to the field of debugging, and in particular relates to a small program plug-in debugging method, device and computer-readable storage medium.

Background technique

This section is intended to provide a background or context for implementations of the invention that are recited in the claims. The descriptions herein are not admitted to be prior art by inclusion in this section.

With the continuous development of the Internet, small programs, as an application that can be used without downloading and installing, have brought new user experience to users. In the past two years, small programs have developed into a sharp tool for connecting industries and serving users. It has played a particularly important role in promoting digital life services.

However, the existing applet plug-in debugging solutions still have some limitations. For example, the debugging of business logic and plug-in calls is usually run in the debugging tool for simulation, not in the production version of the application for debugging, so it cannot Debug comprehensively and realistically.

Contents of the invention

Aiming at the above-mentioned problems in the prior art, a small program plug-in debugging method, system and computer-readable storage medium are proposed, and the above-mentioned problems can be solved by using the method, device and computer-readable storage medium.

The present invention provides the following solutions.

In the first aspect, a small program plug-in debugging method is proposed, including: when the target small program calls the plug-in of the small program to be debugged, the application program sends the first plug-in debugging protocol package to the main process of the debugging tool, wherein the target small program runs in the application In the applet container with the debugging function enabled in the program; when the real machine debugging window is switched to the target debugging panel, the real machine debugging window obtains the first plug-in debugging protocol package from the main process of the debugging tool and parses out the calling information of the small program plug-in, and displays it in Target debugging panel; when the real machine debugging window initiates a plug-in debugging operation for the target debugging panel, the real machine debugging window pushes the second plug-in debugging protocol package to the application through the pre-established two-way communication channel; the application responds to the second plug-in debugging protocol The package enters plugin debug mode.

In some implementations, it also includes the step of establishing a two-way communication channel, including: the main process of the debugging tool obtains debugging information of one or more applets that pass the authorization check from one or more application programs, and the debugging information includes: applets ID, applet container debugging server address; the debugging tool rendering process obtains the debuggable applet list from the debugging tool main process, and the debuggable applet list includes debugging information of one or more applets;

The real machine debugging window obtains the address of the applet container debugging server corresponding to the target applet selected in the debuggable applet list from the debugging tool rendering process; the real machine debugging window connects to the applet corresponding to the target applet as the applet container debugging client. The address of the program container debugging server to establish a two-way communication channel between the real device debugging window and the application program where the target applet is located.

In some implementation manners, it also includes: the communication connection between the application program and the main process of the debugging tool through an encapsulated USB/ADB service channel.

In some embodiments, the first plug-in debugging protocol package is constructed based on a custom plug-in debugging protocol format, and the custom plug-in debugging protocol format includes: method, request, and response; wherein, the method is composed of the main protocol, plug-in name, and plug-in action; request It consists of request ID, request parameters and parameter values; the response consists of callback ID, response parameters and parameter values.

In some embodiments, it also includes: the application obtains the applet configuration information of one or more applets; and performs permission verification according to the applet configuration information; wherein, the permission verification includes one or more of the following: Verify whether the applet is allowed to run, verify whether the applet plug-in is available, and verify whether the debugging permission of the applet is enabled.

In some embodiments, the two-way communication channel is a websocket channel, the applet container debugging server is a websocket server, and the applet container debugging client is a websocket client.

In some implementation manners, the debugging tool rendering process obtains the list of debuggable applets from the debugging tool main process through inter-process communication.

In some implementations, the debugging tool is implemented based on Electron.

In some implementation manners, the real device debugging window is implemented based on Chrome DevTools.

In some implementations, when the real machine debugging window is switched, the switching second plug-in debugging protocol packet is sent based on the two-way communication channel; the application program intercepts switching the second plug-in debugging protocol packet, and the execution schedule switches the corresponding applet container to the foreground .

In the second aspect, a small program plug-in debugging system is provided, including: an application program, a debugging tool main process, and a real machine debugging window; wherein, the target applet runs in a small program container with a debugging function enabled in the application program; the application program, Used to send the first plug-in debugging protocol packet to the main process of the debugging tool when the target applet calls the plug-in of the applet to be debugged; the real device debugging window is used to obtain the first plug-in from the main process of the debugging tool when switching to the target debugging panel Debug the protocol package and parse out the calling information of the applet plug-in, and display it on the target debugging panel; it is also used to push the second plug-in debugging protocol to the application through the pre-established two-way communication channel when the plug-in debugging operation for the target debugging panel is initiated package; an application program for entering a plug-in debug mode in response to the second plug-in debug protocol packet.

In a third aspect, there is provided a small program plug-in debugging device, including: at least one processor; and a memory connected to the at least one processor in communication; wherein, the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by at least one processor. A processor executes, so that at least one processor can execute: the method of the first aspect.

In a fourth aspect, a computer-readable storage medium is provided. The computer-readable storage medium stores a program, and when the program is executed by a multi-core processor, the multi-core processor executes the method of the first aspect.

The above at least one technical solution adopted in the embodiment of the present application can achieve the following beneficial effects: all applet plug-ins are run in the production version of the application program for debugging, providing more comprehensive and real plug-in debugging.

It should be understood that the above description is only an overview of the technical solution of the present invention, so as to understand the technical means of the present invention more clearly, and thus implement it according to the contents of the description. In order to make the above and other objects, features and advantages of the present invention more comprehensible, specific embodiments of the present invention are illustrated below.

Description of drawings

The advantages and benefits herein, as well as other advantages and benefits, will be apparent to those of ordinary skill in the art upon reading the following detailed description of the exemplary embodiments. The drawings are only for the purpose of illustrating exemplary embodiments and are not to be considered as limiting the invention. Also throughout the drawings, the same reference numerals are used to denote the same parts. In the attached picture:

FIG. 1 is a schematic flowchart of a method for debugging a plug-in of a small program according to an embodiment of the present invention;

FIG. 2 is a schematic structural diagram of a small program plug-in debugging system according to an embodiment of the present invention;

FIG. 3 is an interactive schematic diagram of a method for debugging a plug-in of a small program according to an embodiment of the present invention;

FIG. 4 is a schematic flowchart of a method for debugging a plug-in of a small program according to another embodiment of the present invention;

Fig. 5 is a schematic structural diagram of an apparatus for debugging plug-in applets according to yet another embodiment of the present invention.

In the drawings, the same or corresponding reference numerals denote the same or corresponding parts.

Detailed ways

Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited by the embodiments set forth herein. Rather, these embodiments are provided for more thorough understanding of the present disclosure and to fully convey the scope of the present disclosure to those skilled in the art.

In the description of the embodiments of the present application, it should be understood that terms such as "comprising" or "having" are intended to indicate the existence of the features, numbers, steps, acts, components, parts or combinations thereof disclosed in the specification, and do not It is intended to exclude the possibility of the existence of one or more other features, figures, steps, acts, parts, parts or combinations thereof.

Unless otherwise specified, "/" means or, for example, A/B can mean A or B; "and/or" in this article is just an association relationship describing associated objects, indicating that there can be three relationships, For example, A and/or B may mean that A exists alone, A and B exist simultaneously, and B exists alone.

The terms "first", "second", etc. are used for descriptive purposes only, and should not be understood as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first", "second", etc. may expressly or implicitly include one or more of that feature. In the description of the embodiments of the present application, unless otherwise specified, "plurality" means two or more.

All codes in this application are exemplary, and those skilled in the art will think of various modifications without departing from the idea of this application according to factors such as the programming language used, specific requirements, and personal habits.

In addition, it should be noted that, in the case of no conflict, the embodiments of the present invention and the features in the embodiments can be combined with each other. The present invention will be described in detail below with reference to the accompanying drawings and examples.

Fig. 1 is a schematic flowchart of a small program plug-in debugging method according to an embodiment of the present application, which is used to debug the small program plug-in in real time. In this process, from the perspective of equipment, the execution subject may be one or more Electronic equipment; from a program perspective, the execution subject may be a program carried on these electronic equipment.

As shown in Figure 1, the method provided in this embodiment may include the following steps:

S101. When the target applet calls the plug-in of the applet to be debugged, the application program sends the first plug-in debugging protocol package to the main process of the debugging tool;

Wherein, the target applet runs in an applet container with a debugging function enabled in the application program.

Specifically, the delivery of the first plug-in debugging protocol package can be realized through the service channel between the application program and the debugging tool.

In some implementation manners, the communication connection between the application program and the main process of the debugging tool can be implemented through an encapsulated USB/ADB service channel. Optionally, the communication connection between the application program and the main process of the debugging tool may also be implemented through a network service channel.

Specifically, USB (Universal Serial Bus) is used for data communication between devices such as Apple or Android and desktop devices such as computers. ADB (Android Debug Bridge, Android Debug Bridge) is a client-server program, in which the client is the computer used for operation, and the server is the Android device.

The first plug-in debugging protocol package refers to a data package that includes applet calling information constructed based on a custom plug-in debugging protocol format.

In some implementations, the custom plug-in debugging protocol format includes: method, request, and response; wherein, the method is composed of the main protocol, plug-in name, and plug-in action; the request is composed of request ID, request parameters and parameter values; the response is composed of callback ID , response parameters and parameter values.

For example, the plug-in debugging protocol format is as follows, including Method, Request, and Response. Among them, Method consists of: [main agreement. Plug-in name. Plug-in action]. Request consists of: reqId (request Id, incrementally generated) and specific request parameters and parameter values. Response consists of callbackId (callback Id, the value is the same as the request Id) and specific response parameters and parameter values.

S102. When the real machine debugging window is switched to the target debugging panel, the real machine debugging window obtains the first plug-in debugging protocol package from the main process of the debugging tool, parses out the applet plug-in calling information, and displays it on the target debugging panel;

It can be understood that the main process of the debugging tool can store after obtaining the first plug-in debugging protocol package, and only when the real-device debugging window is switched to the target debugging panel for debugging the plug-in, the real-device debugging window needs to obtain it from the storage service. The first plug-in debugging protocol package is parsed to obtain the calling information of the applet plug-in and displayed in the real machine debugging window, so that the developer can trigger the generated plug-in debugging operation in the target debugging panel according to the displayed applet plug-in calling information, such as setting breakpoints etc. The target debugging panel above is a preset panel for plug-in debugging. For example, if the main protocol in the first plug-in debugging protocol package is cordova, it will be displayed in the cordova panel, and if the main protocol is jsbridge, it will be displayed in the jsbridge panel.

S103. When the real machine debugging window initiates a plug-in debugging operation for the target debugging panel, the real machine debugging window pushes the second plug-in debugging protocol package to the application through the pre-established two-way communication channel;

It can be understood that the second plug-in debugging protocol package refers to a data packet based on a custom plug-in debugging protocol format and generated according to a plug-in debugging operation. Since a two-way communication channel has been established in advance as a debugging channel between the real machine debugging window and the applet container running the target applet in the application program, various debugging of the target applet can be realized.

In some implementation manners, the two-way communication channel may be a websocket channel, the applet container debugging server is a websocket server, and the applet container debugging client is a websocket client.

S104. The application program enters a plug-in debugging mode in response to the second plug-in debugging protocol package.

Wherein, the application program can be configured to enter the plug-in debugging mode after receiving the data packet having the format of the plug-in debugging protocol, so that the application program can enter the plug-in debugging mode in response to the second plug-in debugging protocol packet.

Fig. 2 shows an exemplary debugging environment for executing the above S101-104; wherein, the applet container corresponding to the target applet in the application program and the debugging window of the real machine realize a two-way communication connection through a websocket channel, and the application program and the debugging tool host The two-way communication connection is realized between the processes through the USB/ADB service channel, the communication connection is realized between the main process of the debugging tool and the rendering process of the debugging tool through inter-process communication, and the main process of the debugging tool, the rendering process of the debugging tool and the debugging window of the real machine are passed The local storage service realizes the communication connection.

As shown in FIG. 3 , an exemplary interaction diagram based on the embodiment of the present application is shown, and FIG. 3 will be described in detail below in conjunction with FIG. 2 .

S101a, the target applet calls the plug-in of the applet to be debugged; S101b, the application where the target applet is located sends the first plug-in debugging protocol package to the main process of the debugging tool through the USB/ADB service channel; S102a, when the real machine debugging window is switched to the target debugging panel , the real machine debugging window obtains the first plug-in debugging protocol package from the main process of the debugging tool through the local storage service; S102b, the real machine debugging window parses out the plug-in calling information of the applet; S102c, the real machine debugging window displays the applet on the target debugging panel Program plug-in calling information for developers to debug; S103a, the real machine debugging window initiates a plug-in debugging operation for the target debugging panel; S103b, the real machine debugging window pushes the second plug-in debugging protocol package to the application through the pre-established websocket channel ; S104. The application program enters the plug-in debugging mode for the target applet in response to the second plug-in debugging protocol package.

As shown in Figure 4, it shows the steps of how to establish the above-mentioned two-way communication channel, which will be described in detail below in conjunction with Figure 4,

Establishing the above two-way communication channel includes:

S201. The main process of the debugging tool obtains the debugging information of one or more applets that pass the permission verification from one or more applications;

Among them, the applet that passes the permission verification runs in the applet container with the debugging function enabled in the application. The debugging information includes: applet ID, applet container debugging server address. For example, the applet identifier may be the applet page address, the applet title, and the like.

S202. The debugging tool rendering process acquires a debuggable applet list from the debugging tool main process.

Wherein, the debuggable applet list includes debugging information of one or more applets. For example, each item in the list contains debugging information such as the applet page address, title, and the address of the debugging server of the applet container

S203. The real machine debugging window obtains the address of the debugging server of the applet container corresponding to the target applet selected in the list of debuggable applets from the debugging tool rendering process;

Among them, the debugging tool rendering process displays the list of the above-mentioned debuggable applets, and the developer can select the target applet to be debugged through the trigger action, and notify the real device debugging window, so that the real device debugging window can start from the debugging tool rendering process Obtain the address of the applet container debugging server corresponding to the target applet.

S204. The real-device debugging window serves as the applet container debugging client to connect to the address of the applet container debugging server corresponding to the target applet, so as to establish a two-way communication channel between the real-device debugging window and the application where the target applet is located.

For example, after performing the above S201-S204, the exemplary debugging environment shown in FIG. 2 can be obtained.

Optionally, in addition to supporting debugging of applet plug-ins, the debugging environment created based on the above steps 201-204 can also support debugging functions such as applet pages, network requests, and web storage, and supports simultaneous debugging of multiple applets, providing more flexible Efficient multi-instance plugin debugging.

In some implementation manners, before the above S201, in order to perform security management and control of the applet, the following steps may also be performed:

The application program obtains the applet configuration information of one or more applets; and performs permission verification according to the configuration information of the programs; wherein, the permission verification includes one or more of the following: verifying whether the applet is allowed to run, calibrating Check whether the applet plug-in can be used, and verify whether the debugging permission of the applet is enabled.

Further, if the applet passes the above permission verification, the applet can be run in the applet container with the debugging function enabled for subsequent debugging.

In some implementations, the debugging tool is implemented based on Electron. The debugging tool includes a debugging tool main process and a debugging tool rendering process.

A small program plug-in debugging method proposed in the above embodiments of the present application provides cross-terminal, real-time, safe, comprehensive support, non-intrusive, less network dependency, and supports multiple instances of small program plug-in debugging. The applet plug-ins all run in the production version of the application, providing a more comprehensive and real plug-in debugging. And there is no need to deploy the source code of the applet on a specific platform, and the source code does not need to be modified in any way, providing a more secure and controllable solution, which is suitable for fields such as the financial industry with high security requirements.

In the description of this specification, descriptions referring to the terms "some possible implementations", "some embodiments", "examples", "specific examples", or "some examples" mean that the descriptions described in conjunction with the embodiments or examples A particular feature, structure, material, or characteristic is included in at least one embodiment or example of the invention. In this specification, the schematic representations of the above terms are not necessarily directed to the same embodiment or example. Furthermore, the described specific features, structures, materials or characteristics may be combined in any suitable manner in any one or more embodiments or examples. In addition, those skilled in the art can combine and combine different embodiments or examples and features of different embodiments or examples described in this specification without conflicting with each other.

In addition, the terms "first" and "second" are used for descriptive purposes only, and cannot be interpreted as indicating or implying relative importance or implicitly specifying the quantity of indicated technical features. Thus, the features defined as "first" and "second" may explicitly or implicitly include at least one of these features. In the description of the present invention, "plurality" means at least two, such as two, three, etc., unless otherwise specifically defined.

Any process or method descriptions in flowcharts or otherwise described herein may be understood to represent modules, segments or portions of code comprising one or more executable instructions for implementing specific logical functions or steps of the process , and the scope of preferred embodiments of the invention includes alternative implementations in which functions may be performed out of the order shown or discussed, including substantially concurrently or in reverse order depending on the functions involved, which shall It is understood by those skilled in the art to which the embodiments of the present invention pertain.

Regarding the method flow chart of the embodiment of the present application, certain operations are described as different steps performed in a certain order. Such flowcharts are illustrative and not restrictive. Certain steps described herein can be grouped together and performed in a single operation, can be divided into multiple sub-steps, and can be performed in an order different than that shown herein . It can be implemented in any way by any circuit structure and/or tangible mechanism (for example, by software running on a computer device, hardware (for example, logical functions implemented by a processor or a chip), etc., and/or any combination thereof). The individual steps shown in the flowchart.

Based on the same technical concept, an embodiment of the present invention further provides a small program plug-in debugging system, which is used to execute the small program plug-in debugging method provided in any one of the above embodiments. FIG. 2 is a schematic diagram of a small program plug-in debugging system provided by an embodiment of the present invention.

It includes: the application program, the main process of the debugging tool, the rendering process of the debugging tool, and the real machine debugging window; wherein, the target applet runs in the applet container with the debugging function enabled in the application program; the application program is used for When the target applet calls the plug-in of the applet to be debugged, it sends the first plug-in debugging protocol package to the main process of the debugging tool; The process obtains the first plug-in debugging protocol package and parses out the calling information of the applet plug-in, and displays it on the target debugging panel; it is also used for when the plug-in debugging operation for the target debugging panel is initiated, through the pre-established two-way The communication channel pushes a second plug-in debugging protocol package to the application program; the application program is configured to enter a plug-in debugging mode in response to the second plug-in debugging protocol package.

It should be noted that the system in the embodiment of the present application can realize each process of the foregoing method embodiment, and achieve the same effect and function, which will not be repeated here.

Fig. 5 is a small program plug-in debugging device according to an embodiment of the present application, which is used to execute the small program plug-in debugging method shown in Fig. 1 , the device includes: at least one processor; and, communicated with at least one processor A memory; wherein, the memory stores instructions executable by at least one processor, and the instructions are executed by at least one processor, so that the at least one processor can execute the methods described in the above-mentioned embodiments.

According to some embodiments of the present application, there is provided a non-volatile computer storage medium of a small program plug-in debugging method, on which computer executable instructions are stored, and the computer executable instructions are configured to be executed when run by a processor: the above implementation The method described in the example.

Each embodiment in the present application is described in a progressive manner, the same and similar parts of each embodiment can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the apparatus, equipment, and computer-readable storage medium embodiments, since they are basically similar to the method embodiments, their descriptions are simplified, and for relevant parts, please refer to part of the description of the method embodiments.

The device, device, and computer-readable storage medium provided in the embodiments of the present application correspond to the method one-to-one. Therefore, the device, device, and computer-readable storage medium also have beneficial technical effects similar to their corresponding methods. The beneficial technical effect of the method has been described in detail, therefore, the beneficial technical effect of the device, equipment and computer-readable storage medium will not be repeated here.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, systems or computer program products. Accordingly, the present invention can take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor, or processor of other programmable data processing equipment to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing equipment produce a An apparatus for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the instructions The device realizes the function specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart and/or the block or blocks of the block diagrams.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

Memory may include non-permanent storage in computer readable media, in the form of random access memory (RAM) and/or nonvolatile memory such as read-only memory (ROM) or flash RAM. Memory is an example of computer readable media.

Computer-readable media, including both permanent and non-permanent, removable and non-removable media, can be implemented by any method or technology for storage of information. Information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read only memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Flash memory or other memory technology, Compact Disc Read-Only Memory (CD-ROM), Digital Versatile Disc (DVD) or other optical storage, Magnetic tape cartridge, tape magnetic disk storage or other magnetic storage device or any other non-transmission medium that can be used to store information that can be accessed by a computing device. In addition, while operations of the methods of the present invention are depicted in the figures in a particular order, there is no requirement or implication that these operations must be performed in that particular order, or that all illustrated operations must be performed, to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps may be combined into one step for execution, and/or one step may be decomposed into multiple steps for execution.

Although the spirit and principles of the invention have been described with reference to a number of specific embodiments, it should be understood that the invention is not limited to the specific embodiments disclosed, nor does division of aspects imply that features in these aspects cannot be combined to achieve optimal performance. Benefit, this division is only for the convenience of expression. The present invention is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.

Claims

A small program plug-in debugging method, comprising:

When the target applet calls the plug-in of the applet to be debugged, the application sends the first plug-in debugging protocol package to the main process of the debugging tool, wherein the target applet runs in the applet container with the debugging function enabled in the application;

When the real machine debugging window is switched to the target debugging panel, the real machine debugging window obtains the first plug-in debugging protocol package from the main process of the debugging tool and parses out the applet plug-in calling information, and displays it on the target debugging panel ;

When the real machine debugging window initiates a plug-in debugging operation for the target debugging panel, the real machine debugging window pushes a second plug-in debugging protocol package to the application through a pre-established two-way communication channel;

The application program enters a plug-in debugging mode in response to the second plug-in debugging protocol packet.
The method according to claim 1, further comprising the step of establishing the two-way communication channel, comprising:

The main process of the debugging tool obtains the debugging information of one or more applets that have passed the permission verification from one or more application programs, and the debugging information includes: applet identification, applet container debugging server address;

The debugging tool rendering process obtains a debuggable applet list from the debugging tool main process, and the debuggable applet list includes the debugging information of one or more applets;

The real machine debugging window obtains the address of the applet container debugging server corresponding to the target applet selected in the list of debuggable applets from the debugging tool rendering process;

The real machine debugging window is connected to the address of the applet container debugging server corresponding to the target applet as the applet container debugging client, so as to establish a connection between the real machine debugging window and the application where the target applet is located. Two-way communication channel between.
The method according to claim 1 or 2, further comprising:

The application program is communicated with the main process of the debugging tool through an encapsulated USB/ADB service channel.
The method according to any one of claims 1-3, wherein the first plug-in debugging protocol package is constructed based on a custom plug-in debugging protocol format, and the custom plug-in debugging protocol format includes: method, request and response; in,

The method is composed of a main protocol, a plug-in name, and a plug-in action; the request is composed of a request ID, a request parameter and a parameter value; the response is composed of a callback ID, a response parameter and a parameter value.
The method according to any one of claims 2-4, further comprising:

The application obtains the applet configuration information of one or more applets; and performs permission verification according to the applet configuration information;

Wherein, the authority verification includes one or more of the following: verifying whether the applet is allowed to run, verifying whether the applet plug-in is available, and verifying whether the debugging authority of the applet is enabled.
The method according to any one of claims 1-5, wherein the two-way communication channel is a websocket channel, the applet container debugging server is a websocket server, and the applet container debugging client is a websocket client end.
The method according to any one of claims 1-5, wherein the debugging tool rendering process obtains the list of debuggable applets from the debugging tool main process through inter-process communication.
The method according to any one of claims 1-7, wherein the debugging tool is implemented based on Electron.
The method according to any one of claims 1-8, wherein the real machine debugging window is implemented based on Chrome DevTools.
The method according to any one of claims 1-9, wherein, when the real machine debugging window is switched, the second plug-in debugging protocol packet is sent and switched based on the two-way communication channel; the application program intercepts and switches the second plug-in debugging protocol packet , execute scheduling to switch the corresponding applet container to the foreground.
A small program plug-in debugging system, including: an application program, a main process of a debugging tool, and a real machine debugging window; wherein, the target small program runs in a small program container with a debugging function enabled in the application program;

The application program is configured to send a first plug-in debugging protocol packet to the main process of the debugging tool when the target applet calls the plug-in of the applet to be debugged;

The real machine debugging window is used to obtain the first plug-in debugging protocol package from the main process of the debugging tool when switching to the target debugging panel, parse out the applet plug-in call information, and display it on the target debugging panel; It is also used to push the second plug-in debugging protocol package to the application program through the pre-established two-way communication channel when the plug-in debugging operation for the target debugging panel is initiated;

The application program is configured to enter a plug-in debugging mode in response to the second plug-in debugging protocol packet.
A small program plug-in debugging device, comprising:

At least one processor; and, a memory connected in communication with the at least one processor; wherein, the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor, so that the at least one processor can perform: as The method of any one of claims 1-10.
A computer-readable storage medium, the computer-readable storage medium stores a program, and when the program is executed by a multi-core processor, the multi-core processor executes the method described in any one of claims 1-10 method.