Program debugging processing method and device

Abstract

Embodiments of the present specification provide a program debugging processing method and device, wherein a program debugging processing method comprises: generating a debugging address of a subprogram according to a debugging request for performing subprogram debugging on a registered device, and sending the debugging address to a client installed on the registered device; receiving an access request submitted by the client based on the debugging address; performing permission matching verification of the registered device and the subprogram based on identification information carried by the access request; if the verification is passed, pushing a code segment of the subprogram to the client to run the code segment on the client.

Description

TECHNICAL FIELD

[0001] The present document relates to the technical field of data processing, and in particular to a program debugging processing method and device. BACKGROUND

[0002] With the development of Internet technology and the popularity of mobile terminals, more and more services begin to extend to online scenarios. Application platform software capable of carrying multiple application sub-programs appears, avoiding users to install different types of application programs on mobile terminals, but realizing service handling by means of application sub-programs carried in the application platform software. At the same time, application sub-programs can also fully utilize the sufficient user traffic of the application platform software to provide assistance for service improvement of the application sub-programs. SUMMARY

[0003] One or more embodiments of the present specification provide a program debugging processing method applied to a server, the method comprising: generating a debugging address of a sub-program for debugging the sub-program for a registered device according to a debugging request, and sending the debugging address to a client installed on the registered device. Receiving an access request submitted by the client based on the debugging address. Based on the identification information carried by the access request, the permission matching verification of the registered device and the sub-program is performed. If the verification is passed, the code segment of the sub-program is pushed to the client to run the code segment on the client.

[0004] One or more embodiments of the present specification provide another program debugging processing method applied to a client, the method comprising: receiving a debugging address of a sub-program for debugging the sub-program for a registered device sent by a server. Analyzing the debugging address, and submitting an access request of the sub-program to the server based on the analysis result. Receiving the code segment of the sub-program pushed by the server, and running the code segment to debug the sub-program for the registered device running the client. Wherein, the code segment is pushed after the permission matching verification of the registered device and the sub-program is passed.

[0005] One or more embodiments of the present specification provide a program debugging processing device running on a server, the device comprising: a debugging address generation module configured to generate a debugging address of a sub-program for debugging the sub-program for a registered device according to a debugging request, and send the debugging address to a client installed on the registered device. An access request receiving module configured to receive an access request submitted by the client based on the debugging address. A permission matching verification module configured to perform permission matching verification of the registered device and the sub-program based on the identification information carried by the access request. If the verification is passed, a code segment running module is run. The code segment pushing module is configured to push the code segment of the sub-program to the client to run the code segment on the client.

[0006] One or more embodiments of the present specification provide another program debugging processing apparatus running on a client, the apparatus comprising: a debugging address receiving module configured to receive a debugging address for subprogram debugging of a registered device sent by a server. A debugging address resolving module configured to resolve the debugging address and submit an access request of the subprogram to the server based on the resolving result. A code snippet running module configured to receive a code snippet of the subprogram pushed by the server and run the code snippet to perform subprogram debugging on the registered device running the client. Wherein, the code snippet is pushed after the registered device and the subprogram pass the permission matching verification.

[0007] One or more embodiments of the present specification provide a program debugging processing device, comprising: a processor; and a memory configured to store computer executable instructions which, when executed, cause the processor to: generate a debugging address of a subprogram and send to a client installed on a registered device according to a debugging request for subprogram debugging of the registered device. Receive an access request submitted by the client based on the debugging address. Perform permission matching verification of the registered device and the subprogram based on identification information carried by the access request. If the verification passes, push a code snippet of the subprogram to the client to run the code snippet on the client.

[0008] One or more embodiments of the present specification provide another program debugging processing device, comprising: a processor; and a memory configured to store computer executable instructions which, when executed, cause the processor to: receive a debugging address for subprogram debugging of a registered device sent by a server. Resolve the debugging address and submit an access request of the subprogram to the server based on the resolving result. Receive a code snippet of the subprogram pushed by the server and run the code snippet to perform subprogram debugging on the registered device running the client. Wherein, the code snippet is pushed after the registered device and the subprogram pass the permission matching verification.

[0009] One or more embodiments of the present specification provide a storage medium for storing computer executable instructions which, when executed by a processor, implement the following processes: generate a debugging address of a subprogram and send to a client installed on a registered device according to a debugging request for subprogram debugging of the registered device. Receive an access request submitted by the client based on the debugging address. Perform permission matching verification of the registered device and the subprogram based on identification information carried by the access request. If the verification passes, push a code snippet of the subprogram to the client to run the code snippet on the client.

[0010] The one or more embodiments of the specification provide another storage medium for storing computer executable instructions, which, when executed by a processor, implement the following process: receiving a debugging address sent by a server for subprogram debugging of a registered device. Analyzing the debugging address, and submitting an access request of the subprogram to the server based on the analysis result. Receiving a code segment of the subprogram pushed by the server, and running the code segment to debug the subprogram for the registered device running the client. Wherein, the code segment is pushed after the registered device and the subprogram pass the permission matching verification. BRIEF DESCRIPTION OF DRAWINGS

[0011] In order to more clearly illustrate the technical solutions in the one or more embodiments of the specification or the prior art, the drawings needed to be used in the embodiment or prior art description will be briefly introduced. Obviously, the drawings in the following description are only some embodiments described in the specification, and those skilled in the art can also obtain other drawings according to these drawings without creative labor;

[0012] Figure 1 A program debugging processing method processing flowchart is provided for the one or more embodiments of the specification;

[0013] Figure 2 A program development debugging process schematic diagram is provided for the one or more embodiments of the specification;

[0014] Figure 3 Another program debugging processing method processing flowchart is provided for the one or more embodiments of the specification;

[0015] Figure 4 A program debugging processing device schematic diagram is provided for the one or more embodiments of the specification;

[0016] Figure 5 Another program debugging processing device schematic diagram is provided for the one or more embodiments of the specification;

[0017] Figure 6 A program debugging processing device structure schematic diagram is provided for the one or more embodiments of the specification;

[0018] Figure 7 Another program debugging processing device structure schematic diagram is provided for the one or more embodiments of the specification. DETAILED DESCRIPTION

[0019] In order to make the person skilled in the art better understand the technical solutions in one or more embodiments of the present specification, the technical solutions in one or more embodiments of the present specification will be clearly and completely described below in conjunction with the drawings in one or more embodiments of the present specification. Obviously, the described embodiments are only a part of the embodiments of the present specification, not all. Based on one or more embodiments of the present specification, all other embodiments obtained by those skilled in the art without creative labor should belong to the protection scope of the present document.

[0020] An embodiment of a program debugging processing method provided by the present specification is as follows:

[0021] Referring to Figure 1 The program debugging processing method provided in the embodiment is applied to a server, and the method specifically includes steps S102 to S108.

[0022] Step S102, according to the debugging request for subprogram debugging of the registered device, the debugging address of the subprogram is generated and sent to the client installed on the registered device.

[0023] The program debugging processing method provided in the present application, in the subprogram debugging process, the terminal device to be debugged is registered as a registered device through a device registration process in advance, and a client for loading and running the subprogram is installed on the registered device. The subprogram is debugged for the registered device through the cooperation of the client and the server. Specifically, the debugging address of the subprogram is sent to the client as the basis for the client to initiate debugging access, and the debugging matching verification is carried out from the identification information carried by the access request submitted by the client. In the case where the verification is passed, the code segment of the subprogram is pushed to the client, so that the real machine debugging of the subprogram is carried out through the registered device on the basis of running the code segment of the subprogram on the client, which improves the convenience and debugging efficiency of the real machine debugging of the subprogram. At the same time, the debugging process is standardized through the permission matching verification, which avoids the interference of malicious debugging on the terminal device and ensures the normal operation of the device.

[0024] The subprogram refers to a program function module or application component loaded in an application program or client, or a program function module or application component loaded and installed by an application program or client, such as a subprogram in an application program. From the perspective of service, the subprogram has the ability to independently provide a self-closed loop service, such as a subprogram running in a payment application platform with the self-closed loop ability of service booking and booking message pushing.

[0025] In this embodiment, for a terminal device performing subprogram debugging, the terminal device is opened to perform corresponding subprogram debugging by performing device registration processing on the terminal device. The registered device refers to the terminal device after the device registration processing. The terminal device includes, but is not limited to, at least one of the following: a vehicle-mounted terminal, a terminal device connected to a vehicle, a smart sound box, a self-service vending machine, a self-operated radio, an interactive advertising screen, a POS device, and a smart television, a smart refrigerator, and other smart home appliances. A party or parties providing the terminal device are referred to as a device provider. The device provider specifically includes a production party, a sales party, and / or a service and operation party of the terminal device.

[0026] Under the premise of providing subprograms for terminal devices, the device provider needs to develop more targeted subprograms for terminal devices in order to provide subprograms with higher adaptability to terminal devices. In the development process of subprograms by the device provider, there is a need to use terminal devices for subprogram real machine debugging. This embodiment takes the scenario of subprogram development and debugging by the device provider as an example to illustrate the process of subprogram debugging for terminal devices.

[0027] Specifically, in the subprogram debugging process, a corresponding tool needs to be used for subprogram debugging. In this embodiment, a debugging tool is used to debug subprograms on the registered device. For example, the device provider uses a MiniU development and debugging tool to debug subprograms on the registered device that has performed device registration processing.

[0028] Based on this, in the process of subprogram debugging by the device provider using the debugging tool for the registered device, in order to strengthen the authority control in the subprogram debugging process and avoid interference with the normal operation of the device caused by malicious debugging, this embodiment realizes debugging authority control by binding the debugging tool with the subprogram. Optionally, the debugging request is submitted through the debugging tool. The debugging tool is bound with a program signature obtained by the device provider for the subprogram, and the debugging authority of the subprogram is opened to the debugging tool after binding. By binding the debugging tool with the program signature, the influence of invalid or "malicious" debugging on different subprograms through one debugging tool is avoided, the authority control in the subprogram debugging process is improved, and the debugging experience in the subprogram real machine debugging process is improved.

[0029] Further, in the process of subprogram debugging by the device provider using the debugging tool for the registered device, optionally, the debugging tool is obtained and installed by the device provider of the registered device, and the subprogram is developed by the device provider. For example, the device provider of the registered device provides a MiniU development and debugging tool, and the device provider develops a subprogram for the registered device. Figure 2The device provider of the registered device A shown locally installs the MiniU development debugging tool using the npm command, and the device provider develops the subprogram by using the installed MiniU development debugging tool.

[0030] In this embodiment, for a specific terminal device which is not configured with a display screen or is inconvenient to scan the code in an active scanning manner, a debugging address is sent to the registered device, and a debugging access trigger is triggered in the registered device by means of the debugging address, so that real machine debugging of the subprogram in the registered device is performed. Specifically, in the debugging process, a client is installed in the registered device, and on the basis that the client and the server establish data communication and the debugging tool and the server establish data communication, the debugging tool realizes the control of the subprogram debugging of the registered device. The client refers to a program container running in the terminal device, which provides a running framework or a running engine for loading and running the subprogram in the terminal device. By installing the program container in the terminal device, the access to the subprogram in the terminal device can be realized. It should be noted that the client here refers to a client encapsulated for subprogram debugging, or the client can be understood as a debugging client of the subprogram to be debugged, which has the ability to access the subprogram to be debugged in the registered device.

[0031] In the process of the device provider using the debugging tool to debug the subprogram of the registered device, the client is installed in the registered device by the device provider of the registered device. Optionally, the registered device runs the client when starting. The data link established between the client and the server is kept in a long connection state during the running of the client.

[0032] Specifically, the registered device will call the system application on which it depends when starting. After the system application is called, the initialization call to the client is initiated. The client establishes a data link with the server in response to the initialization call. After receiving the initialization call, the client remains in a running state. In the case where the client remains in a running state after establishing the data link, the data link is kept in a long connection state after being established, so as to realize the remote real-time control of the subprogram debugging by the debugging tool by means of the data link.

[0033] To improve the consistency of the subprogram debugging process, the terminal device that needs to be debugged is registered by the terminal device registration process, and the registered device that completes the debugging registration obtains the right to debug the corresponding subprogram, so as to avoid the interference of "malicious" debugging on the normal operation of the device. Optionally, the registered device registered by the debugging tool has a permission access relationship with the subprogram; and the registered device that is not registered by the debugging tool or the terminal device that is not registered has no permission access relationship with the subprogram, that is, the registered device that is not registered by the debugging tool or the terminal device that is not registered has a permission isolation relationship with the subprogram.

[0034] In the above-mentioned scenario of developing and debugging the subprogram by the device provider of the terminal device, first, the device provider installs the debugging tool locally, and develops the subprogram by using the locally installed debugging tool, and then binds the locally installed debugging tool with the program signature of the developed subprogram. Secondly, the terminal device that needs to be debugged is registered by the debugging tool, and the registered device installed by the registration process carries the client running the subprogram, thereby providing the development and debugging of the subprogram for the device provider. From the perspective of the device provider, the development and debugging of the subprogram are helpful to improve the adaptability of the subprogram to the registered device, and also helpful to improve the compatibility of the subprogram to different device usage scenarios.

[0035] It should be noted that in addition to the above-mentioned scenario of developing and debugging the subprogram by the device provider of the terminal device, the subprogram can also be developed by the application developer and debugged by the device provider for the terminal device; or the subprogram is developed by the service provider or the maintenance provider of the application program or the client carrying the subprogram, and the device provider debugs the subprogram for the terminal device. The implementation of the subprogram debugging process is similar to the above-mentioned subprogram debugging process, please refer to the specific implementation of the above-mentioned subprogram debugging process, which will not be described here in this embodiment.

[0036] In a specific implementation, in a subprogram debugging process, a debugging address of the subprogram is generated according to a debugging request for subprogram debugging of the registered device, and is sent to a client installed on the registered device. In a process of generating the debugging address of the subprogram in a scenario in which the device provider performs subprogram debugging on the registered device by using a debugging tool, the debugging address is generated based on a tool identifier of the debugging tool, a program identifier of the subprogram, and a device identifier of the registered device, and is sent to the registered device on which the client is installed, to the server through a data link established by the client and the server, so that the registered device initiates debugging of the subprogram by triggering the debugging address. In addition, in the process of generating the debugging address, the debugging address can also be generated based on any two or one of the tool identifier of the debugging tool, the program identifier of the subprogram, and the device identifier of the registered device, and no limitation is made in this regard.

[0037] In step S104, the access request submitted by the client based on the debugging address is received.

[0038] The above step sends the debugging address of the subprogram to the client. After receiving the debugging address, the client parses the debugging address, and submits an access request of the subprogram to the server based on a parsing result. In this step, the access request submitted by the client is received.

[0039] In step S106, the registered device and the subprogram are subjected to permission matching verification based on the identifier information carried in the access request.

[0040] The identifier information includes a tool identifier of a debugging tool, a program identifier of the subprogram, and / or a device identifier of the registered device. The permission matching verification refers to verification of whether the subprogram currently subjected to debugging is a subprogram developed by a device provider, and whether a terminal device currently subjected to subprogram debugging is a registered device subjected to device registration processing by the device provider through a debugging tool.

[0041] In an optional implementation provided by the embodiment, the registered device and the subprogram are subjected to permission matching verification based on the identifier information carried in the access request, and the permission matching verification is implemented in the following manner:

[0042] checking whether the tool identifier carried in the access request corresponds to the debugging tool with open debugging permission, whether the program identifier corresponds to a subprogram bound with a program signature of the debugging tool, and / or whether the device identifier carried in the access request corresponds to a registered device having a permission access relationship with the subprogram; if yes, determining that the checking is passed; if no, determining that the checking is not passed; and optionally, in the case that the checking is not passed, returning a prompt information of the checking not passed to the client.

[0043] In step S108, if the checking is passed, a code segment of the subprogram is pushed to the client to run the code segment on the client.

[0044] In the case that the checking result of the above permission matching checking is passed, a code segment of the subprogram is pushed to the client to run the code segment on the client. In the process of pushing the code segment of the subprogram to the client, the data link established between the client and the server is used to push the code segment of the subprogram to the client, and the client runs the code segment after receiving the code segment to cooperate with the device provider to perform the remote debugging of the subprogram on the registered device through the debugging tool.

[0045] It should be noted that, in addition to the above implementation process of the permission matching checking and the code segment pushing performed by the server, in order to improve the processing efficiency of the debugging process, the server can be divided into multiple sub-servers, and each sub-server performs the corresponding processing process of the above subprogram debugging, for example, the server is divided into a debugging server, a device management platform and a subprogram management system. The debugging server generates a debugging address of the subprogram according to a debugging request for the subprogram debugging of the registered device and sends the debugging address to the client installed on the registered device. After receiving an access request submitted by the client based on the debugging address, the device management platform sends a checking request to the device management platform based on the identifier information carried in the access request. The device management platform performs the permission matching checking of the registered device and the subprogram based on the identifier information, and sends a pushing instruction to the subprogram management system after the checking is passed. The subprogram management system pushes a code segment of the subprogram to the client according to the pushing instruction.

[0046] In actual application, after the development and debugging of the subprogram by the device provider for the registered device are completed, the device provider can publish the subprogram online, and in this process, the device provider can install a publishing client on the registered device for device login processing and service scenario subscription processing of the registered device. The device login processing is based on the application account of the third-party application of the device user of the registered device for login. The subprogram is registered in a subprogram pool accessed by the third-party application, and the registered subapplication can be debugged by the registered device using the debugging tool.

[0047] The publishing client refers to the complete version of the client, which is different from the client encapsulated for the debugging of the subprogram. The subprograms in the subprogram pool are all subprograms accessed by the third-party application. In this embodiment, the registered device is limited by limited running resources and cannot directly run the third-party application to access the subprograms in the subprogram pool. Therefore, the access to the subprograms in the subprogram pool is realized by running the lightweight application (i.e., the publishing client) of the third-party application on the registered device, which reduces the running pressure of the registered device in the subprogram access process, improves the flexibility and diversity of the use of the registered device, and improves the adaptability of the registered device to the actual use scenario through the open service scenario subscription mode, and meets the diversified needs of users in the use of the registered device.

[0048] The following further describes the program debugging processing method provided in this embodiment by taking the application of the program debugging processing method provided in this embodiment in a program development and debugging scenario as an example. The following describes the program debugging processing method provided in this embodiment in combination with the accompanying drawings. Figure 2 The program debugging processing method in a program development and debugging scenario is specifically described.

[0049] Before debugging, the device manufacturer installs a MiniU development and debugging tool locally, develops a subprogram using the MiniU development and debugging tool, and binds the MiniU development and debugging tool with the program signature of the developed subprogram;

[0050] In the debugging preparation stage, the device manufacturer performs device registration processing on the terminal device for subprogram debugging by using the MiniU development and debugging tool, obtains a registered device, and installs a program container carrying a subprogram running on the registered device. The registered device that performs device registration processing by using the MiniU development and debugging tool has a permission access relationship with the subprogram corresponding to the program signature bound to the MiniU development and debugging tool.

[0051] The debugging process specifically includes:

[0052] (1) The device manufacturer sends a debugging request for subprogram debugging of the registered device to the debugging server through the MiniU development debugging tool; the debugging request carries the tool identifier of the MiniU development debugging tool of the device manufacturer, the program identifier of the subprogram developed by the device manufacturer, and the device identifier of the registered device;

[0053] (2) After the debugging server receives the debugging request for subprogram debugging of the registered device, the debugging server generates a debugging address of the subprogram according to the tool identifier, the program identifier, and the device identifier, and sends the debugging address to the program container installed on the registered device;

[0054] (3) After the program container receives the debugging address, the program container parses the debugging address and sends an access request of the subprogram to the debugging server based on the parsing result;

[0055] (4) After the debugging server receives the access request submitted by the program container, the debugging server sends a verification request to the device management platform based on the tool identifier, the program identifier, and the device identifier carried in the access request;

[0056] (5) The device management platform performs permission matching verification based on the tool identifier, the program identifier, and the device identifier, and sends a push instruction to the subprogram management system after the verification is passed;

[0057] The permission matching verification specifically includes: verifying whether the tool identifier corresponds to a MiniU development debugging tool that has open debugging permission; if yes, further verifying whether the subprogram corresponding to the program identifier is a subprogram that is bound to the MiniU development debugging tool by program signature; if yes, further verifying whether the device identifier corresponds to a registered device that has a permission access relationship with the subprogram; if yes, it is determined that the verification is passed; if no, it is determined that the verification is not passed, and a reminder information that the verification is not passed is returned to the program container;

[0058] (6) The subprogram management system pushes the code segment of the subprogram to the program container according to the push instruction.

[0059] (7) After the program container receives the pushed code segment of the subprogram, the program container runs the code segment to cooperate with the MiniU development debugging tool to debug the subprogram on the registered device.

[0060] Another embodiment of the program debugging processing method provided in the specification:

[0061] The program debugging processing method applied to the client provided in this embodiment cooperates with the program debugging processing method applied to the server provided in the above embodiment in the execution process, and cooperates with the program debugging processing method applied to the server provided in the following embodiment in the execution process, therefore, when reading this embodiment, please refer to the corresponding content of the above embodiment and the following embodiment.

[0062] Referring to Figure 3 The program debugging processing method provided in the embodiment is applied to a client, and specifically includes steps S302 to S306.

[0063] In step S302, a debugging address for subprogram debugging of a registered device is received from a server.

[0064] The subprogram refers to a program function module or application component carried in an application program or client, or a program function module or application component loaded and installed by an application program or client, such as a subprogram in an application program. From the perspective of service, the subprogram has the ability to independently provide a self-loop service, such as a subprogram running in a payment application platform with the self-loop ability of service booking and booking message pushing.

[0065] In the embodiment, for a terminal device performing subprogram debugging, the terminal device is opened to perform corresponding subprogram debugging by performing device registration processing on the terminal device. The registered device refers to a terminal device after device registration processing, and the terminal device includes at least one of the following: a car machine terminal installed in a vehicle, a terminal device connected to a vehicle, a smart sound box, a self-service vending machine, a self-service radio, an interactive advertising screen, a POS device, and a smart television, a smart refrigerator, and other smart home appliances. A party or parties providing the terminal device are called device providers, and the device providers specifically include a production party, a sales party, and / or a service operation party of the terminal device.

[0066] Under the premise of providing subprograms for terminal devices, the device providers need to develop more targeted subprograms for terminal devices in order to provide subprograms with higher adaptability to terminal devices, and there is a need to use terminal devices to perform subprogram real machine debugging during the development of subprograms by the device providers. The embodiment takes the scenario of developing and debugging subprograms by the device providers as an example to illustrate the process of subprogram debugging for terminal devices.

[0067] Specifically, in the subprogram debugging process, a corresponding tool needs to be used to perform subprogram debugging. In the embodiment, a debugging tool is used to perform subprogram debugging on the registered device. For example, a MiniU development and debugging tool is used by the device providers to perform real machine debugging of subprograms on the registered device that has performed device registration processing.

[0068] Based on this, in the process of the device provider using the debugging tool to debug the subprogram of the registered device, in order to strengthen the authority control in the subprogram debugging process and avoid interference to the normal operation of the device caused by malicious debugging, the embodiment realizes the debugging authority control by binding the debugging tool and the subprogram. Optionally, the debugging request is submitted through the debugging tool, the debugging tool is bound with the program signature applied and obtained by the device provider for the subprogram, and the debugging authority of the subprogram is opened to the debugging tool after the binding. By binding the debugging tool and the program signature, the influence caused by invalid or "malicious" debugging of different subprograms through one debugging tool is avoided, the authority control in the subprogram debugging process is improved, and the debugging experience in the subprogram real machine debugging process is improved.

[0069] Further, in the process of the device provider using the debugging tool to debug the subprogram of the registered device, optionally, the debugging tool is obtained and installed by the device provider of the registered device, and the subprogram is developed by the device provider. For example, as shown in the following figure, the device provider of the registered device A uses the npm command to locally install the MiniU development debugging tool, and the device provider uses the installed MiniU development debugging tool to develop the subprogram. Figure 2 Further, in the process of the device provider using the debugging tool to debug the subprogram of the registered device, optionally, the debugging tool is obtained and installed by the device provider of the registered device, and the subprogram is developed by the device provider. For example, as shown in the following figure, the device provider of the registered device A uses the npm command to locally install the MiniU development debugging tool, and the device provider uses the installed MiniU development debugging tool to develop the subprogram.

[0070] In this embodiment, for a specific terminal device which is not configured with a display screen or is not convenient to scan the code in an active scanning code manner, the debugging address sent to the registered device is used to trigger the debugging access of the debugging address on the registered device, so that the real machine debugging of the subprogram on the registered device is performed. Specifically, in the debugging process, the client is installed on the registered device, and the data communication between the client and the server and the data communication between the debugging tool and the server are established, so that the debugging control of the debugging tool on the subprogram of the registered device is realized. The client is a program container running on the terminal device, which provides a running framework or a running engine for loading and running the subprogram on the terminal device. By installing the program container on the terminal device, the access to the subprogram on the terminal device can be realized. It should be noted that the client here is a client encapsulated for subprogram debugging, or the client can be understood as a debugging client of the subprogram to be debugged, which has the ability to access the subprogram to be debugged on the registered device.

[0071] In the process of the device provider using the debugging tool to debug the subprogram of the registered device, the client is installed on the registered device by the device provider of the registered device. Optionally, the client is run when the registered device is started, and the data link established between the client and the server is kept in a long connection state during the running of the client.

[0072] Specifically, the registration device arouses a system application relied on by the registration device when starting, the system application arouses an initialization call to the client after being aroused, the client establishes a data link with the server in response to the initialization call, and the client remains in a running state after receiving the initialization call. In the case where the client remains in a running state after establishing the data link, the data link is maintained in a long connection state after being established, so that the remote real-time control of the subprogram debugging by the debugging tool is realized through the data link.

[0073] To improve the processing consistency in the subprogram debugging process, the terminal device that needs to be debugged is registered for debugging through device registration processing of the terminal device, and the registration device that completes the debugging registration obtains the permission to perform the corresponding subprogram debugging, so as to avoid interference of "malicious" debugging on the normal operation of the device. Optionally, the registration device that performs the device registration processing through the debugging tool has a permission access relationship with the subprogram; and the registration device that does not perform the device registration processing through the debugging tool or the terminal device that does not perform the device registration processing does not have a permission access relationship with the subprogram, that is, the registration device that does not perform the device registration processing through the debugging tool or the terminal device that does not perform the device registration processing has a permission isolation relationship with the subprogram.

[0074] In the above-mentioned scenario of developing and debugging the subprogram by the device provider of the terminal device, first, the device provider locally installs the debugging tool, and develops the subprogram by using the locally installed debugging tool, and then binds the locally installed debugging tool with the program signature of the developed subprogram. Secondly, the terminal device that needs to be debugged is registered for debugging by the debugging tool, and the client that carries the subprogram is installed in the registration device obtained through the registration processing, so that the development and debugging of the subprogram are provided for the device provider. From the perspective of the device provider, the development and debugging of the subprogram are helpful to improve the adaptability of the subprogram to the registration device, and also helpful to improve the compatibility of the subprogram to different device usage scenarios.

[0075] It should be noted that, in addition to the above-mentioned scenario of developing and debugging the subprogram by the device provider of the terminal device, the subprogram can also be developed by an application development party and debugged by the device provider for the terminal device; or the subprogram can be developed by a service party or a maintenance party of an application program or a client that carries the subprogram, and the subprogram can be debugged by the device provider for the terminal device. The implementation of the subprogram debugging process is similar to the above-mentioned subprogram debugging process, and the specific implementation of the subprogram debugging process is described above. Therefore, the embodiment will not be described here.

[0076] In the subprogram debugging scenario in which the device provider utilizes the debugging tool to debug the registered device, the debugging address is generated based on the tool identifier of the debugging tool, the program identifier of the subprogram, and the device identifier of the registered device; in addition, the debugging address can also be generated based on any two or one of the tool identifier of the debugging tool, the program identifier of the subprogram, and the device identifier of the registered device, and no limitation is made in this regard.

[0077] In step S304, the debugging address is parsed, and an access request of the subprogram is submitted to the server based on the parsing result.

[0078] Optionally, the access request carries identification information, and the identification information includes at least one of the following: a tool identifier, a program identifier, and a device identifier.

[0079] In step S306, the code segment of the subprogram pushed by the server is received, and the code segment is run to debug the subprogram for the registered device on which the client is run.

[0080] The code segment is pushed after the permission matching verification of the registered device and the subprogram is passed. The permission matching verification specifically includes: verifying whether the tool identifier carried in the access request corresponds to the debugging tool with open debugging permission, whether the subprogram corresponding to the program identifier is a subprogram bound with the program signature of the debugging tool, and / or whether the device identifier carried in the access request corresponds to the registered device having a permission access relationship with the subprogram; if yes, it is determined that the verification is passed; if no, it is determined that the verification is not passed.

[0081] In actual application, in the process in which the device provider utilizes the debugging tool to debug the subprogram for the registered device, after the development and debugging process of the subprogram for the registered device performed by the device provider is completed, the device provider can publish the subprogram online, in this process, the device provider can install a publishing client on the registered device, which is used to perform device login processing and service scenario subscription processing of the registered device; the device login processing is performed based on the application account of the third-party application of the device user of the registered device; the subprogram is registered in a subprogram pool accessed by the third-party application by the device provider, and the registered subprogram can be debugged for the registered device by utilizing the debugging tool.

[0082] The publishing client refers to the complete version of the client, which is distinguished from the client encapsulated for debugging the subprogram. The subprograms in the subprogram pool are subprograms accessed by the third-party application. In the embodiment, the registration device is limited by limited running resources and cannot directly run the third-party application to access the subprograms in the subprogram pool. Therefore, the access to the subprograms in the subprogram pool is realized through the lightweight application (i.e., the publishing client) running the third-party application on the registration device, which reduces the running pressure of the registration device in the subprogram access process, improves the flexibility and diversity of the registration device, and improves the adaptability of the registration device to the actual use scene through the open service scene subscription mode, thereby meeting the diversified needs of users in the use of the registration device.

[0083] The program debugging processing method provided in the embodiment is further described below by taking the application of the program debugging processing method provided in the embodiment in a program development and debugging scene as an example. The following describes the program debugging processing method provided in the embodiment in combination with the accompanying Figure 2 The program debugging processing method for the program development and debugging scene is described in detail.

[0084] Before debugging, the device manufacturer installs a MiniU development and debugging tool locally, develops a subprogram by using the MiniU development and debugging tool, and binds the MiniU development and debugging tool with the program signature of the developed subprogram;

[0085] In the debugging preparation stage, the device manufacturer performs device registration processing on a terminal device for subprogram debugging by using the MiniU development and debugging tool, obtains a registration device, and installs a program container carrying a subprogram running on the registration device. The registration device that is processed by the MiniU development and debugging tool has a permission access relationship with a subprogram corresponding to the program signature bound to the MiniU development and debugging tool.

[0086] The debugging process specifically includes the following steps.

[0087] (1) The device manufacturer sends a debugging request for subprogram debugging of the registration device to the debugging server by using the MiniU development and debugging tool. The debugging request carries the tool identifier of the MiniU development and debugging tool of the device manufacturer, the program identifier of the subprogram developed by the device manufacturer, and the device identifier of the registration device.

[0088] (2) After receiving the debugging request for subprogram debugging of the registration device, the debugging server generates a debugging address of the subprogram according to the tool identifier, the program identifier, and the device identifier and sends the debugging address to the program container installed on the registration device.

[0089] (3) The program container parses the debugging address after receiving the debugging address and sends an access request of the subprogram to the debugging server based on the parsing result;

[0090] (4) The debugging server sends a verification request to the device management platform based on the tool identifier, the program identifier and the device identifier carried by the access request after receiving the access request submitted by the program container;

[0091] (5) The device management platform performs permission matching verification based on the tool identifier, the program identifier and the device identifier, and sends a push instruction to the subprogram management system after the verification is passed;

[0092] The permission matching verification specifically includes: verifying whether the tool identifier corresponds to a MiniU development and debugging tool with open debugging permission; if yes, further verifying whether the subprogram corresponding to the program identifier is a subprogram bound with the program signature and the MiniU development and debugging tool; if yes, further verifying whether the device identifier corresponds to a registered device having a permission access relationship with the subprogram; if yes, it is determined that the verification is passed; if no, it is determined that the verification is not passed, and the program container is returned with a prompt information that the verification is not passed;

[0093] (6) The subprogram management system pushes the code segment of the subprogram to the program container according to the push instruction.

[0094] (7) The program container runs the code segment after receiving the pushed code segment of the subprogram to cooperate with the MiniU development and debugging tool to debug the subprogram on the registered device.

[0095] The program debugging processing device provided in the specification implements, for example:

[0096] In the above embodiment, a program debugging processing method applied to a server is provided, and a program debugging processing device running on the server is also provided, which will be described below with reference to the accompanying drawings.

[0097] Reference Figure 4 which shows a program debugging processing device schematic diagram provided in the embodiment.

[0098] Since the device embodiment corresponds to the method embodiment, it is described more simply, and the related parts can be referred to the above-mentioned corresponding description of the method embodiment. The device embodiment described below is only schematic.

[0099] The embodiment provides a program debugging processing device running on a server, and the device comprises:

[0100] The debugging address generation module 402 is configured to generate a debugging address of the subprogram according to a debugging request for subprogram debugging of the registered device, and send the debugging address to a client installed on the registered device.

[0101] The access request receiving module 404 is configured to receive an access request submitted by the client based on the debugging address.

[0102] The permission matching verification module 406 is configured to perform permission matching verification of the registered device and the subprogram based on identification information carried in the access request.

[0103] If the verification passes, the code segment pushing module 408 is run; the code segment pushing module 408 is configured to push a code segment of the subprogram to the client, so as to run the code segment on the client.

[0104] Another program debugging processing device provided in the specification implements, for example, the following:

[0105] In the above embodiment, a program debugging processing method applied to a client is provided, and a program debugging processing device running on the client is also provided, which will be described below with reference to the accompanying drawings.

[0106] Reference Figure 5 which shows a program debugging processing device schematic diagram provided in the embodiment.

[0107] Since the device embodiment corresponds to the method embodiment, the description is relatively simple, and the related parts can be seen in the above-mentioned corresponding description of the method embodiment. The device embodiments described below are only schematic.

[0108] The embodiment provides a program debugging processing device running on a client, and the device comprises:

[0109] The debugging address receiving module 502 is configured to receive a debugging address of a subprogram sent by a server for debugging of a registered device.

[0110] The debugging address analysis module 504 is configured to analyze the debugging address, and submit an access request of the subprogram to the server based on the analysis result.

[0111] The code segment running module 506 is configured to receive a code segment of the subprogram pushed by the server, and run the code segment to debug the subprogram for the registered device running the client.

[0112] The code segment is pushed after the permission matching verification of the registered device and the subprogram passes.

[0113] The program debugging processing device provided in the specification implements, for example, the following:

[0114] Corresponding to the above description, based on the same technical concept, one or more embodiments of the specification also provide a program debugging processing device for executing the program debugging processing method provided above, Figure 6 A structural diagram of a program debugging processing device provided for one or more embodiments of the specification.

[0115] The program debugging processing device provided in the embodiment includes:

[0116] As Figure 6 shown, the program debugging processing device can have a large difference due to different configurations or performance, and can include one or more processors 601 and memories 602, and the memories 602 can store one or more storage applications or data. Among them, the memory 602 can be temporary storage or persistent storage. The application stored in the memory 602 can include one or more modules (not shown in the figure), and each module can include a series of computer executable instructions in the program debugging processing device. Further, the processor 601 can be configured to communicate with the memory 602 and execute a series of computer executable instructions in the memory 602 on the program debugging processing device. The program debugging processing device can also include one or more power supplies 603, one or more wired or wireless network interfaces 604, one or more input / output interfaces 605, one or more keyboards 606, etc.

[0117] In one specific embodiment, the program debugging processing device includes a memory and one or more programs, wherein one or more programs are stored in the memory, and one or more programs can include one or more modules, and each module can include a series of computer executable instructions in the program debugging processing device, and the one or more processors configured to execute the one or more programs include computer executable instructions for:

[0118] According to the debugging request for subprogram debugging of the registered device, the debugging address of the subprogram is generated and sent to the client installed on the registered device;

[0119] Receive the access request submitted by the client based on the debugging address;

[0120] Based on the identification information carried by the access request, the permission matching verification of the registered device and the subprogram is performed;

[0121] If the verification passes, the code segment of the subprogram is pushed to the client to run the code segment at the client.

[0122] Another program debugging processing device provided by the present specification implements, for example, the following:

[0123] Corresponding to the above description, based on the same technical concept, one or more embodiments of the present specification also provide a program debugging processing device for executing the program debugging processing method provided above, Figure 7 A structural schematic diagram of a program debugging processing device provided by one or more embodiments of the present specification.

[0124] The program debugging processing device provided in the present embodiment comprises:

[0125] As shown in Figure 7 The program debugging processing device can have great differences due to different configurations or performances, and can include one or more processors 701 and memories 702, and the memories 702 can store one or more storage applications or data. Among them, the memory 702 can be temporary storage or persistent storage. The application stored in the memory 702 can include one or more modules (not shown in the figure), and each module can include a series of computer executable instructions in the program debugging processing device. Further, the processor 701 can be configured to communicate with the memory 702 and execute a series of computer executable instructions in the memory 702 on the program debugging processing device. The program debugging processing device can also include one or more power supplies 703, one or more wired or wireless network interfaces 704, one or more input / output interfaces 705, one or more keyboards 706, etc.

[0126] In one specific embodiment, the program debugging processing device includes a memory and one or more programs, wherein one or more programs are stored in the memory, and the one or more programs can include one or more modules, and each module can include a series of computer executable instructions in the program debugging processing device, and the one or more processors configured to execute the one or more programs include computer executable instructions for:

[0127] Receiving the debugging address for subprogram debugging of the registered device sent by the server;

[0128] Analyzing the debugging address, and submitting an access request for the subprogram to the server based on the analysis result;

[0129] receive the code segment of the subprogram pushed by the server and run the code segment to perform subprogram debugging for the registered device running the client;

[0130] The code segment is pushed after the registered device and the subprogram pass the permission matching verification.

[0131] The storage medium provided in the specification implements, for example, the following:

[0132] According to the above description, a program debugging processing method applied to a server is provided, and based on the same technical concept, one or more embodiments of the specification also provide a storage medium.

[0133] The storage medium provided in the embodiment is used to store computer executable instructions, and the computer executable instructions are executed by the processor to implement the following processes:

[0134] According to the debugging request for subprogram debugging of the registered device, the debugging address of the subprogram is generated and sent to the client installed on the registered device;

[0135] Receive the access request submitted by the client based on the debugging address;

[0136] Based on the identification information carried by the access request, the permission matching verification of the registered device and the subprogram is performed;

[0137] If the verification is passed, the code segment of the subprogram is pushed to the client to run the code segment on the client.

[0138] It should be noted that the embodiments of the storage medium in the specification and the embodiments of the program debugging processing method in the specification are based on the same inventive concept, so the specific implementation of the embodiments can refer to the implementation of the corresponding method described above, and the repeated parts will not be described here.

[0139] Another storage medium provided in the specification implements, for example, the following:

[0140] According to the above description, a program debugging processing method applied to a client is provided, and based on the same technical concept, one or more embodiments of the specification also provide a storage medium.

[0141] The storage medium provided in the embodiment is used to store computer executable instructions, and the computer executable instructions are executed by the processor to implement the following processes:

[0142] Receive the debugging address of the subprogram debugging of the registered device sent by the server;

[0143] The debugging address is parsed, and an access request of the subprogram is submitted to the service end based on a parsing result;

[0144] The code segment of the subprogram pushed by the service end is received, and the code segment is run to perform subprogram debugging on the registered device of the running client;

[0145] The code segment is pushed after the registered device and the subprogram pass the permission matching verification.

[0146] It should be noted that the embodiments of the storage medium in the present specification are based on the same inventive concept as the embodiments of the program debugging processing method in the present specification, and therefore the specific implementation of the embodiments can be referred to the implementation of the corresponding method described above, and the repeated parts will not be described herein.

[0147] The specific embodiments of the present specification are described above. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims can be performed in a different order and still achieve desirable results. Additionally, the process depicted in the figures does not necessarily require the particular order shown or sequential order in order to achieve the desired results. In some implementations, multitasking and parallel processing can be advantageous or necessary.

[0148] In the 1930s, it was clear to distinguish whether an improvement in a technology was in hardware (e.g., improvement in circuit structure of diodes, transistors, switches, etc.) or in software (e.g., improvement in method flow). However, as technology has evolved, many improvements in method flow today can be considered as direct improvements in hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved method flow into the hardware circuit. Therefore, it cannot be said that an improvement in a method flow cannot be implemented by a hardware entity module. For example, a programmable logic device (PLD) (e.g., a field programmable gate array (FPGA)) is an integrated circuit whose logic function is determined by user programming of the device. A digital system is "integrated" on a PLD by the designer programming it, rather than by asking a chip manufacturer to design and fabricate a custom integrated circuit chip. Moreover, instead of manually fabricating an integrated circuit chip, this programming is now mostly implemented by "logic compiler" software, which is similar to software compilers used in program development, and the original code to be compiled is written in a specific programming language, called a hardware description language (HDL), of which there are many, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc., the most commonly used being VHDL (Very-High-Speed Integrated Circuit Hardware Description Language) and Verilog. It should be clear to those skilled in the art that, by simply logically programming a method flow in one of the above hardware description languages and programming it into an integrated circuit, a hardware circuit implementing the logical method flow can be easily obtained.

[0149] The controller can be implemented in any suitable way, e.g. the controller can take the form of a microprocessor or processor and a computer readable medium storing computer readable program code, e.g. software or firmware, executable by the (micro)processor, logic gates, switches, an application specific integrated circuit (ASIC), a programmable logic controller and an embedded microcontroller, examples of controllers include but are not limited to the following microcontrollers: ARC 625D, Atmel AT91 SAM, Microchip PIC18F26K20 and Silicone Labs C8051F320, the memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also know that in addition to being implemented in pure computer readable program code form, the controller can perfectly well be implemented by means of logic programmed into logic gates, switches, application specific integrated circuits, programmable logic controllers and embedded microcontrollers, etc. to perform the same functions. The controller can thus be considered a hardware component, and the means comprised therein for performing various functions can be considered structures within the hardware component. Alternatively, or even additionally, the means for performing various functions can be considered both software modules implementing the method and structures within the hardware component.

[0150] The systems, apparatuses, modules or units illustrated by the above embodiments can be implemented by computer chips or entities, or products with certain functions. A typical implementation device is a computer. Specifically, the computer can be a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0151] For the sake of description, the above apparatuses are described in various units by functions respectively. Of course, the functions of each unit can be implemented in the same or multiple software and / or hardware in the implementation of the embodiments of the present specification.

[0152] Those skilled in the art will appreciate that one or more embodiments of the specification can be provided as a method, system or computer program product. Therefore, one or more embodiments of the specification can take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects. Moreover, the specification can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROMs, optical storage devices, etc.) containing computer usable program code.

[0153] The specification is presented with reference to flow diagrams and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the specification. It will be understood that each block of the flow diagrams and / or block diagrams, and combinations of blocks in the flow diagrams and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general purpose computer, special purpose computer, embedded processing element or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flow diagrams and / or block diagrams block or blocks. Figure 1 The flow diagrams and / or block diagrams in the specification can present a method, apparatus or computer program product according to embodiments of the specification. Although the flow diagrams and / or block diagrams can present a method, apparatus or computer program product in a particular, it is understood that the method, apparatus and computer program product can include one or more additional steps, operations, or functions, and the method, apparatus and computer program product can include one or more other steps, operations, functions or combinations of steps, operations, or functions in Figure 1 The flow diagrams and / or block diagrams in the specification can present a method, apparatus or computer program product according to embodiments of the specification. Although the flow diagrams and / or block diagrams can present a method, apparatus or computer program product in a particular, it is understood that the method, apparatus and computer program product can include one or more additional steps, operations, or functions, and the method, apparatus and computer program product can include one or more other steps, operations, functions or combinations of steps, operations, or functions in

[0154] The computer program instructions can also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flow diagrams and / or block diagrams block or blocks. Figure 1 The flow diagrams and / or block diagrams in the specification can present a method, apparatus or computer program product according to embodiments of the specification. Although the flow diagrams and / or block diagrams can present a method, apparatus or computer program product in a particular, it is understood that the method, apparatus and computer program product can include one or more additional steps, operations, or functions, and the method, apparatus and computer program product can include one or more other steps, operations, functions or combinations of steps, operations, or functions in Figure 1 The flow diagrams and / or block diagrams in the specification can present a method, apparatus or computer program product according to embodiments of the specification. Although the flow diagrams and / or block diagrams can present a method, apparatus or computer program product in a particular, it is understood that the method, apparatus and computer program product can include one or more additional steps, operations, or functions, and the method, apparatus and computer program product can include one or more other steps, operations, functions or combinations of steps, operations, or functions in

[0155] The computer program instructions can also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flow diagrams and / or block diagrams block or blocks. Figure 1 The flow diagrams and / or block diagrams in the specification can present a method, apparatus or computer program product according to embodiments of the specification. Although the flow diagrams and / or block diagrams can present a method, apparatus or computer program product in a particular, it is understood that the method, apparatus and computer program product can include one or more additional steps, operations, or functions, and the method, apparatus and computer program product can include one or more other steps, operations, functions or combinations of steps, operations, or functions in Figure 1 The flow diagrams and / or block diagrams in the specification can present a method, apparatus or computer program product according to embodiments of the specification. Although the flow diagrams and / or block diagrams can present a method, apparatus or computer program product in a particular, it is understood that the method, apparatus and computer program product can include one or more additional steps, operations, or functions, and the method, apparatus and computer program product can include one or more other steps, operations, functions or combinations of steps, operations, or functions in

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

[0157] The memory can include non-persistent memory, Random Access Memory (RAM), and / or non-volatile memory, such as read only memory (ROM) or flash memory, among others in a computer readable medium. The memory is an example of computer readable media.

[0158] Computer-readable media includes permanent and non-permanent, movable and non-movable media that can be implemented by any method or technology to store information. The information can be computer-readable instructions, data structures, program modules 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 technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassette, magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information accessible to a computing device. According to the definition herein, computer-readable media does not include transitory media such as modulated data signals and carriers.

[0159] It should also be noted that the terms "comprising", "containing", or any other variant thereof are intended to cover non-exclusive inclusion, such that processes, methods, articles or devices that include a series of elements not only include those elements, but also include other elements not explicitly listed or inherent to such processes, methods, articles or devices. Without more limitations, the element defined by the statement "comprising a" does not exclude the presence of additional identical elements in the process, method, article or device comprising the element.

[0160] One or more embodiments of the specification can be described in the general context of computer-executable instructions being executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types. One or more embodiments of the specification can also be practiced in a distributed computing environment, in which tasks are performed by remote processing devices connected through a communication network. In a distributed computing environment, program modules can be located in local and remote computer storage media, including storage devices.

[0161] Each embodiment in the specification is described in a progressive manner, and the same or similar parts between each embodiment can be referred to each other, and each embodiment focuses on the difference from other embodiments. In particular, for system embodiments, since they are basically similar to method embodiments, the description is relatively simple, and the relevant parts can be referred to the part of the method embodiment.

[0162] The above merely provides the example of the present document and is not intended to limit the present document. For those skilled in the art, the present document can have various modifications and changes. Any modification, equivalent replacement, improvement, etc. within the spirit and principle of the present document shall be included in the scope of claims of the present document.

Claims

1. A program debugging processing method applied to a server, the method comprising: generating a debugging address of a subprogram according to a debugging request for debugging the subprogram submitted by a debugging tool for a registered device, and sending the debugging address to a client installed on the registered device; binding the debugging tool with a program signature of the subprogram and obtaining a debugging permission of the subprogram after the binding; receiving an access request submitted by the client based on the debugging address; performing a permission matching verification of the registered device and the subprogram based on identification information carried by the access request; if the verification passes, pushing a code segment of the subprogram to the client to run the code segment on the client. 2.The program debugging processing method of claim 1, wherein the program signature is obtained by a device provider applying for the subprogram. 3.The program debugging processing method of claim 2, wherein a registered device that performs a device registration process through the debugging tool has a permission access relationship with the subprogram; and a registered device that does not perform the device registration process through the debugging tool or a terminal device that does not perform the device registration process has a permission isolation relationship with the subprogram. 4.The program debugging processing method of claim 3, wherein the performing the permission matching verification of the registered device and the subprogram based on the identification information carried by the access request comprises: verifying whether a tool identification carried by the access request corresponds to the debugging tool that opens a debugging permission, whether a program identification corresponding to the subprogram is the subprogram bound with the debugging tool by the program signature, and / or whether a device identification carried by the access request corresponds to the registered device that has the permission access relationship with the subprogram; if yes, determining that the verification passes; and if no, determining that the verification does not pass. 5.The program debugging processing method of claim 4, further comprising: if the verification does not pass, returning a prompt information that the verification does not pass to the client. 6.The program debugging processing method of claim 2, wherein the debugging tool is obtained and installed by a device provider of the registered device, and the subprogram is developed by the device provider. 7.The program debugging processing method of claim 6, wherein the registered device runs the client when starting, and a data link established by the client and the server remains in a long connection state during the running of the client; and the code segment is pushed to the client through the data link. 8.The program debugging processing method of claim 1, wherein after the debugging of the subprogram for the registered device is completed, a publishing client installed on the registered device is used to perform a device login process and a service scenario subscription process of the registered device; the device login process is performed based on an application account of a third-party application of a device user of the registered device; and the subprogram is registered in a subprogram pool accessed by the third-party application by a device provider. 9.A program debugging processing method applied to a client, the method comprising: ​ ​ ​ ​ ​ ​ ​ ​ wherein ​ ​ ​ receive a debugging address for debugging a subprogram of a registered device sent by a service end; the debugging address is generated according to a debugging request submitted by a debugging tool, the debugging tool is bound with a program signature of the subprogram and obtains a debugging permission of the subprogram after being bound; parse the debugging address and submit an access request of the subprogram to the service end based on a parsing result; receive a code segment of the subprogram pushed by the service end and run the code segment to debug the subprogram for the registered device running the client; wherein the code segment is pushed after passing a permission matching verification of the registered device and the subprogram.

10. The program debugging processing method according to claim 9, wherein the program signature is applied for by a device provider for the subprogram.

11. The program debugging processing method according to claim 10, wherein a registered device that performs a device registration processing through the debugging tool has a permission access relationship with the subprogram; a registered device that does not perform the device registration processing through the debugging tool or a terminal device that does not perform the device registration processing has a permission isolation relationship with the subprogram.

12. The program debugging processing method according to claim 11, wherein the access request carries identification information, and the identification information includes at least one of the following: tool identification, program identification, device identification.

13. The program debugging processing method according to claim 10, wherein the debugging tool is obtained and installed by a device provider of the registered device, and the subprogram is developed by the device provider.

14. The program debugging processing method according to claim 13, wherein the registered device runs the client when starting, a data link established by the client and the service end maintains a long connection state during running of the client; the code segment is pushed to the client through the data link.

15. The program debugging processing method according to claim 9, wherein after the subprogram debugging for the registered device is completed, a publishing client installed in the registered device is used to perform a device login processing and a service scene subscription processing of the registered device; wherein the device login processing is based on an application account of a third-party application of a device user of the registered device; the subprogram is registered in a subprogram pool accessed by the third-party application by the device provider.

16. A program debugging processing apparatus running in a service end, comprising: a debugging address generation module configured to generate a debugging address of a subprogram according to a debugging request submitted by a debugging tool for debugging a subprogram of a registered device and send the debugging address to a client installed in the registered device; the debugging tool is bound with a program signature of the subprogram and obtains a debugging permission of the subprogram after being bound; an access request receiving module configured to receive an access request submitted by the client based on the debugging address; a permission matching verification module configured to perform a permission matching verification of the registered device and the subprogram based on identification information carried by the access request. if the verification passes, a code snippet pushing module is run to push the code snippet of the subprogram to the client to run the code snippet on the client; the code snippet pushing module is configured to push the code snippet of the subprogram to the client to run the code snippet on the client.

17. A program debugging processing apparatus running on a client, the apparatus comprising: a debugging address receiving module configured to receive a debugging address for subprogram debugging of a registered device sent by a server; the debugging address is generated according to a debugging request submitted by a debugging tool, the debugging tool is bound to a program signature of a subprogram and obtains a debugging permission of the subprogram after being bound; a debugging address resolving module configured to resolve the debugging address and submit an access request of the subprogram to the server based on a resolving result; a code snippet running module configured to receive a code snippet of the subprogram pushed by the server and run the code snippet to perform subprogram debugging on a registered device running the client; wherein the code snippet is pushed after a permission matching verification between the registered device and the subprogram passes.

18. A program debugging processing device comprising: a processor; and a memory configured to store computer executable instructions which, when executed, cause the processor to: generate a debugging address of a subprogram according to a debugging request submitted by a debugging tool for subprogram debugging of a registered device and send the debugging address to a client installed on the registered device; the debugging tool is bound to a program signature of the subprogram and obtains a debugging permission of the subprogram after being bound; receive an access request submitted by the client based on the debugging address; perform a permission matching verification between the registered device and the subprogram based on identification information carried by the access request; if the verification passes, push a code snippet of the subprogram to the client to run the code snippet on the client.

19. A program debugging processing device comprising: a processor; and a memory configured to store computer executable instructions which, when executed, cause the processor to: receive a debugging address for subprogram debugging of a registered device sent by a server; the debugging address is generated according to a debugging request submitted by a debugging tool, the debugging tool is bound to a program signature of a subprogram and obtains a debugging permission of the subprogram after being bound; resolve the debugging address and submit an access request of the subprogram to the server based on a resolving result; receive a code snippet of the subprogram pushed by the server and run the code snippet to perform subprogram debugging on a registered device running a client; wherein the code snippet is pushed after a permission matching verification between the registered device and the subprogram passes.

20. A storage medium for storing computer executable instructions which, when executed by a processor, implement the following processes: According to the debugging request for the registered device submitted by the debugging tool, the debugging address of the subprogram is generated and sent to the client installed on the registered device; the debugging tool is bound to a program signature of the subprogram and obtains a debugging permission of the subprogram after being bound; receive an access request submitted by the client based on the debugging address; Based on the identification information carried by the access request, the registered device and the subprogram are matched and verified for permission; If the verification is passed, the code segment of the subprogram is pushed to the client to run the code segment on the client.

21. A storage medium for storing computer executable instructions, the computer executable instructions, when executed by a processor, implement the following processes: receiving a debugging address sent by the service end for debugging a subprogram of the registered device; The debugging address is generated according to a debugging request submitted by a debugging tool, the debugging tool is bound with a program signature of a subprogram and obtains a debugging permission of the subprogram after being bound; The debugging address is parsed, and an access request of the subprogram is submitted to the server based on the parsing result; The code segment of the subprogram pushed by the server is received, and the code segment is run to debug the subprogram for the registered device of the running client; The code segment is pushed after the permission matching verification of the registered device and the subprogram is passed.

Images