Debugging device and method for large-screen terminal

Abstract

The present invention discloses a debugging device and method for a large-screen terminal, and relates to the field of computer technology. A specific implementation of the debugging device includes: an underlying component, an interactive component, and a debugging panel; wherein the underlying component runs on a simulation terminal, and is used to simulate one or more functional components of the large-screen terminal; the interactive component is used to simulate the application to be run on the large-screen terminal, and call the underlying component according to the logic of the application; the debugging panel is used to monitor the execution of the application, and to set the simulation terminal according to the functional components and version information of the large-screen terminal. This implementation combines the hardware functions and native functions of the large-screen terminal to debug the application on the simulation terminal, so that the developed and debugged application is more compatible with the large-screen terminal.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a debugging device and method for a large-screen terminal. Background Art

[0002] With the development of visualization technology, large-screen terminals are used more and more widely. Large-screen terminals mainly refer to terminal devices with large-size display screens, such as large-screen TVs, large-screen advertising machines, and BI (Business Intelligence) large-screen display terminals.

[0003] At present, many applications can be run on large-screen terminals, and each application needs to be debugged before it can be put online. After the application of existing large-screen terminals is developed, it is impossible to directly use the hardware functions and native capabilities of the large-screen terminals. For example, the hardware functions such as cameras and printers on large-screen terminals and native capabilities such as face recognition cannot be used directly, so there is no way to test the compatibility between the application and the functional components of the large-screen terminal. It is difficult to accurately debug the application of the large-screen terminal according to the actual functional components of the large-screen terminal, which may cause the developed application to be incompatible with the large-screen terminal. Summary of the invention

[0004] In view of this, an embodiment of the present invention provides a debugging device and method for a large-screen terminal, which accurately simulates the execution of an application on a large-screen terminal through a simulation terminal, so as to facilitate debugging of the application. In addition, since the functional components simulated on the simulation terminal can correspond to the hardware functions and native functions of the large-screen terminal, the application can be debugged on the simulation terminal in combination with the hardware functions and native functions of the large-screen terminal, so that the developed and debugged application is more compatible with the large-screen terminal.

[0005] To achieve the above object, according to one aspect of an embodiment of the present invention, a debugging device for a large-screen terminal is provided, comprising: a bottom layer component, an interactive component and a debugging panel; wherein:

[0006] The bottom layer component runs on the simulation terminal and is used to simulate one or more functional components of the large-screen terminal;

[0007] The interactive component is used to simulate the application to be run on the large-screen terminal and call the underlying component according to the logic of the application;

[0008] The debugging panel is used to monitor the execution status of the application and to set the simulation terminal according to the functional components and version information of the large-screen terminal.

[0009] Optionally, the underlying components include one or more of the following: a camera, a printer, a microphone, a speaker, a browser kernel, and an SDK.

[0010] Optionally, the SDK includes one or more of the following: a face recognition SDK, a voice recognition SDK, and a gesture recognition SDK.

[0011] Optionally, the interactive component determines the browser kernel in the called underlying component according to the version information of the large-screen terminal.

[0012] Optionally, the interactive component includes an application to be run on the large-screen terminal, a JS-SDK, a web view control, and a native API for calling the underlying component.

[0013] Optionally, the application to be run on the large-screen terminal provides an interactive test on the application by accessing a remote URL.

[0014] Optionally, the application to be run on the large-screen terminal provides an interactive test on the application by calling static resources stored in the simulated terminal.

[0015] Optionally, the debugging panel is further used to set the display effect of the simulation terminal according to the screen size of the large-screen terminal.

[0016] Optionally, the simulation terminal is a mobile terminal.

[0017] According to another aspect of an embodiment of the present invention, a debugging method for a large-screen terminal is provided, comprising: running underlying components through a simulation terminal to simulate one or more functional components of the large-screen terminal;

[0018] Simulate the application to be run on the large-screen terminal through the interactive component, and call the underlying component according to the logic of the application;

[0019] The execution of the application is monitored through a debugging panel, and the simulation terminal is set according to the functional components and version information of the large-screen terminal.

[0020] One embodiment of the above invention has the following advantages or beneficial effects: the functional components of the large-screen terminal are simulated through the simulation terminal, and the application to be run on the large-screen terminal is simulated through the interactive component. The underlying components are called according to the logic of the application. During the execution of the application, the execution of the application can be monitored and displayed through the debugging panel, so that the simulation terminal can be set according to the functional components and version information of the large-screen terminal, so that the execution of the application on the large-screen terminal can be accurately simulated through the simulation terminal, which is convenient for debugging the application. In addition, since the functional components simulated on the simulation terminal can correspond to the hardware functions and native functions of the large-screen terminal, the application can be debugged on the simulation terminal in combination with the hardware functions and native functions of the large-screen terminal, so that the developed and debugged application is more compatible with the large-screen terminal.

[0021] The further effects of the above-mentioned non-conventional optional manner will be described below in conjunction with the specific implementation manner. BRIEF DESCRIPTION OF THE DRAWINGS

[0022] The accompanying drawings are used to better understand the present invention and do not constitute an improper limitation of the present invention.

[0023] Figure 1 is a schematic diagram of the structure of a debugging device for a large-screen terminal according to an embodiment of the present invention;

[0024] Figure 2 is a structural schematic diagram of another debugging device for a large-screen terminal according to an embodiment of the present invention;

[0025] Figure 3 It is a flowchart of a debugging method for a large-screen terminal according to an embodiment of the present invention;

[0026] Figure 4 is an exemplary system architecture diagram to which embodiments of the present invention may be applied;

[0027] Figure 5 It is a schematic diagram of the structure of a computer system of a terminal device or a server suitable for implementing an embodiment of the present invention. DETAILED DESCRIPTION

[0028] The following is a description of exemplary embodiments of the present invention in conjunction with the accompanying drawings, including various details of the embodiments of the present invention to facilitate understanding, which should be considered as merely exemplary. Therefore, it should be recognized by those of ordinary skill in the art that various changes and modifications may be made to the embodiments described herein without departing from the scope and spirit of the present invention. Similarly, for clarity and conciseness, the description of well-known functions and structures is omitted in the following description.

[0029] Figure 1 A debugging device 100 for a large-screen terminal according to an embodiment of the present invention is shown in FIG. Figure 1 As shown, the debugging device 100 mainly includes: a bottom component 101, an interactive component 102 and a debugging panel 103; wherein,

[0030] The bottom layer component 101 runs on the simulation terminal and is used to simulate one or more functional components of the large-screen terminal;

[0031] The interactive component 102 is used to simulate the application to be run on the large-screen terminal and call the underlying component 101 according to the logic of the application;

[0032] The debugging panel 103 is used to monitor the execution status of the application and to set the simulation terminal according to the functional components and version information of the large-screen terminal.

[0033] The simulation terminal may be a mobile terminal, such as a mobile phone terminal and a PC, etc. Since most developers have mobile terminals such as mobile phones and PCs, the debugging device for a large-screen terminal provided in the embodiment of the present invention simulates the execution of an application on a large-screen terminal through a mobile terminal, that is, provides a debugging tool in the form of a mobile terminal, which is convenient for developers to debug applications.

[0034] The underlying components corresponding to the functional components of the large-screen terminal run on the simulation terminal. For example, when the large-screen terminal has functions such as a camera and a printer, the underlying components also simulate the functions of the camera and the printer. In an embodiment of the present invention, according to the different functions of the large-screen terminal, the underlying components include a camera, a printer, a microphone, a speaker, a browser kernel, and an SDK (Software Development Kit). Among them, the underlying components such as the camera, the microphone, and the speaker can use the functional components that come with the mobile terminal. If the mobile terminal does not have the corresponding function, the corresponding underlying components can be generated using simulated data to make full use of the native capabilities of the mobile terminal. For example, according to the function of the large-screen terminal, the SDK in the underlying components may include a face recognition SDK, a voice recognition SDK, and a gesture recognition SDK. If the mobile terminal has face recognition and voice recognition functions, the native capabilities of the mobile terminal are fully utilized, and the face recognition and voice recognition functions of the mobile terminal are adopted; if the mobile terminal does not have a gesture recognition function, the gesture recognition SDK corresponding to the large-screen terminal can be configured in advance on the simulation terminal to generate the underlying components on the simulation terminal according to the configured gesture recognition SDK.

[0035] In addition, the interactive components include applications that will be run on the large-screen terminal, JS-SDK (JavaScript-Software Development Kit), web view controls, and native APIs (Application Programming Interface) for calling the underlying components. Among them, the applications that will be run on the large-screen terminal include various web applications such as H5, Cocos, Unity3d, and layabox; the web view controls are mainly used to load applications, and the applications interact with the native APIs of the underlying components through JS-SDK for data, hardware device management, face recognition / gesture recognition and other data transmission, as well as voice data transmission.

[0036] like Figure 2The schematic diagram of the structure of the debugging device of the large-screen terminal shown in the figure shows that during the debugging process, the application to be run on the large-screen terminal can provide interactive testing of the application by accessing a remote URL (Uniform Resource Locator) or by calling static resources stored in the simulation terminal. For example, a developer can start a server to directly load a remote URL link, which is simple and fast, and convenient for debugging. In addition, the application to be run on the large-screen terminal can also provide interactive testing of the application by calling static resources stored in the simulation terminal. For example, when the simulation terminal is a mobile phone terminal, the static resource package can be stored in the local storage card of the mobile phone terminal and started with the static resources of the storage card, which can facilitate the verification of the correctness of the application and greatly reduce the error rate of publishing the application.

[0037] In one embodiment of the present invention, since the version of the large-screen terminal may be different from the running version of the simulation terminal, in order to make the debugged application more compatible with the large-screen terminal, the interactive component can determine the browser kernel in the called underlying component based on the version information of the large-screen terminal.

[0038] Generally speaking, the version of the large-screen terminal is lower, and the browser kernel that can run on the simulation terminal may not be able to run on the large-screen terminal. Therefore, it is necessary to determine the browser kernel in the underlying component to be called according to the version information of the large-screen terminal, so that the simulation terminal can more accurately simulate the execution of the application on the large-screen terminal. For example, when both the large-screen terminal and the simulation terminal use the Android system, but the version information of the two is different, if the underlying component of the simulation terminal includes the X5 browser kernel, the interactive component can automatically switch whether to use the X5 browser kernel according to the version information of the large-screen terminal (if the version of the large-screen terminal is too low, the X5 browser kernel will not be used), thereby solving the problem that the kernel version of the large-screen terminal is too low and the application cannot be loaded.

[0039] In another embodiment of the present invention, the debugging panel can also set the display effect of the simulation terminal according to the screen size of the large-screen terminal. For example, when the simulation terminal is a mobile phone terminal, the debugging panel can set the display effect on the mobile phone terminal according to the ratio between the screen size of the large-screen terminal and the screen size of the mobile phone terminal, and / or according to the ratio between the resolution of the large-screen terminal and the resolution of the mobile phone terminal. Since the screen size of the large-screen terminal is larger than that of the mobile phone terminal, when setting the display effect, the display screen is generally reduced according to the ratio of resolution / screen size.

[0040] In summary, the debugging device of the large-screen terminal provided by the embodiment of the present invention simulates the functional components of the large-screen terminal through the simulation terminal, and simulates the application to be run on the large-screen terminal through the interactive component, and calls the underlying components according to the logic of the application. During the execution of the application, the execution of the application can be monitored and displayed through the debugging panel, so as to set the simulation terminal according to the functional components and version information of the large-screen terminal, so as to accurately simulate the execution of the application on the large-screen terminal through the simulation terminal, which is convenient for debugging the application. In addition, since the functional components simulated on the simulation terminal can correspond to the hardware functions and native functions of the large-screen terminal, the application can be debugged on the simulation terminal in combination with the hardware functions and native functions of the large-screen terminal, so that the developed and debugged application is more compatible with the large-screen terminal.

[0041] The debugging device of the large-screen terminal provided by the embodiment of the present invention can debug multiple web applications, not limited to technologies and engines such as H5, Cocos, Unity3d, layabox, etc., and provides developers with a quick development method through the simulation terminal. It only needs to call the JS-SDK in the interactive component to complete the call of the underlying component, and the native capabilities in the simulation terminal are fully utilized by the developer, which is convenient for making better applications. In addition, the browser kernel in the underlying component called can be determined according to the version information of the large-screen terminal, thereby solving the problem that the low-version large-screen terminal cannot load the front-end application, and also provides a set of convenient debugging panels to facilitate problem finding.

[0042] like Figure 3 As shown, an embodiment of the present invention also provides a debugging method for a large-screen terminal, which mainly includes:

[0043] Step S301: Run the underlying components through the simulated terminal to simulate one or more functional components of the large-screen terminal.

[0044] Step S302: simulating the application to be run on the large-screen terminal through the interactive component, and calling the underlying component according to the logic of the application.

[0045] Step S303: monitor the execution status of the application through the debugging panel, and set the simulation terminal according to the functional components and version information of the large-screen terminal.

[0046] In one embodiment of the present invention, the simulated terminal is a mobile terminal.

[0047] In one embodiment of the present invention, the underlying components include one or more of the following: a camera, a printer, a microphone, a speaker, a browser kernel, and an SDK.

[0048] In one embodiment of the present invention, the SDK includes one or more of the following: a face recognition SDK, a voice recognition SDK, and a gesture recognition SDK.

[0049] In one embodiment of the present invention, the interactive component determines the browser kernel in the called underlying component according to the version information of the large-screen terminal.

[0050] In one embodiment of the present invention, the interactive component includes an application to be run on the large-screen terminal, a JS-SDK, a web view control, and a native API for calling the underlying component.

[0051] In one embodiment of the present invention, the application to be run on the large-screen terminal provides an interactive test on the application by accessing a remote URL.

[0052] In one embodiment of the present invention, the application to be run on the large-screen terminal provides an interactive test on the application by calling static resources stored in the simulation terminal.

[0053] In one embodiment of the present invention, the display effect of the simulation terminal can also be set according to the screen size of the large-screen terminal through a debugging panel.

[0054] Figure 4 An exemplary system architecture 400 is shown to which a debugging device or a debugging method for a large-screen terminal according to an embodiment of the present invention can be applied.

[0055] like Figure 4 As shown, system architecture 400 may include terminal devices 401, 402, 403, network 404 and server 405. Network 404 is used to provide a medium for communication links between terminal devices 401, 402, 403 and server 405. Network 404 may include various connection types, such as wired, wireless communication links or optical fiber cables, etc.

[0056] The user can use the terminal devices 401, 402, 403 to interact with the server 405 through the network 404 to receive or send messages, etc. The terminal devices 401, 402, 403 can be analog terminals on which various communication client applications are installed, such as shopping applications, web browser applications, search applications, instant messaging tools, email clients, social platform software, etc.

[0057] The terminal devices 401 , 402 , and 403 may be various electronic devices having a display screen and supporting web browsing, including but not limited to smart phones, tablet computers, laptop computers, and desktop computers.

[0058] The server 405 may be a server that provides various services, such as a background management server that provides a response when a user uses the terminal devices 401, 402, and 403 to debug an application in URL mode (only as an example). The background management server may analyze and process the received query request and other data, and feed back the processing results to the terminal device.

[0059] It should be noted that the debugging method for the large-screen terminal provided in the embodiment of the present invention is generally executed by the terminal devices 401 , 402 , and 403 . Accordingly, the debugging device for the large-screen terminal is generally arranged in the terminal devices 401 , 402 , and 403 .

[0060] It should be understood that Figure 4 The number of terminal devices, networks and servers in the embodiment is only for illustration. Any number of terminal devices, networks and servers may be provided according to implementation requirements.

[0061] Reference below Figure 5 , which shows a schematic diagram of the structure of a computer system 500 of a terminal device suitable for implementing an embodiment of the present invention. Figure 5 The terminal device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present invention.

[0062] like Figure 5 As shown, the computer system 500 includes a central processing unit (CPU) 501, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 502 or a program loaded from a storage part 508 into a random access memory (RAM) 503. In the RAM 503, various programs and data required for the operation of the system 500 are also stored. The CPU 501, the ROM 502, and the RAM 503 are connected to each other via a bus 504. An input / output (I / O) interface 505 is also connected to the bus 504.

[0063] The following components are connected to the I / O interface 505: an input section 506 including a keyboard, a mouse, etc.; an output section 507 including a cathode ray tube (CRT), a liquid crystal display (LCD), etc., and a speaker, etc.; a storage section 508 including a hard disk, etc.; and a communication section 509 including a network interface card such as a LAN card, a modem, etc. The communication section 509 performs communication processing via a network such as the Internet. A drive 510 is also connected to the I / O interface 505 as needed. A removable medium 511, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is installed on the drive 510 as needed, so that a computer program read therefrom is installed into the storage section 508 as needed.

[0064] In particular, according to the embodiments disclosed in the present invention, the process described above with reference to the flowchart can be implemented as a computer software program. For example, the embodiments disclosed in the present invention include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from the network through the communication part 509, and / or installed from the removable medium 511. When the computer program is executed by the central processing unit (CPU) 501, the above-mentioned functions defined in the system of the present invention are executed.

[0065] It should be noted that the computer-readable medium shown in the present invention may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present invention, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in combination with an instruction execution system, device or device. In the present invention, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, which carries a computer-readable program code. This propagated data signal may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. Computer-readable signal media may also be any computer-readable medium other than computer-readable storage media, which may send, propagate or transmit a program for use by or in conjunction with an instruction execution system, apparatus or device. The program code contained on the computer-readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, optical cable, RF, etc., or any suitable combination of the above.

[0066] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, functions and operations of the system, method and computer program product according to various embodiments of the present invention. In this regard, each box in the flow chart or block diagram can represent a module, a program segment, or a part of a code, and the above-mentioned module, program segment, or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order from the order marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram or flow chart, and the combination of the boxes in the block diagram or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0067] As another aspect, the present invention also provides a computer-readable medium, which may be included in the device described in the above embodiment; or may exist independently without being assembled into the device. The above computer-readable medium carries one or more programs, and when the above one or more programs are executed by a device, the device includes: running the underlying components through the simulation terminal to simulate one or more functional components of the large-screen terminal; simulating the application to be run on the large-screen terminal through the interactive component, and calling the underlying component according to the logic of the application; monitoring the execution of the application through the debugging panel, and setting the simulation terminal according to the functional components and version information of the large-screen terminal.

[0068] According to the technical solution of the embodiment of the present invention, the functional components of the large-screen terminal are simulated through the simulation terminal, and the application to be run on the large-screen terminal is simulated through the interactive component. The underlying components are called according to the logic of the application. During the execution of the application, the execution of the application can be monitored and displayed through the debugging panel, so that the simulation terminal can be set according to the functional components and version information of the large-screen terminal, so that the execution of the application on the large-screen terminal can be accurately simulated through the simulation terminal, which is convenient for debugging the application. In addition, since the functional components simulated on the simulation terminal can correspond to the hardware functions and native functions of the large-screen terminal, the application can be debugged on the simulation terminal in combination with the hardware functions and native functions of the large-screen terminal, so that the developed and debugged application is more compatible with the large-screen terminal.

[0069] The above specific implementations do not constitute a limitation on the protection scope of the present invention. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may occur depending on design requirements and other factors. Any modification, equivalent substitution and improvement made within the spirit and principle of the present invention shall be included in the protection scope of the present invention.

Claims

1. A debugging device for a large-screen terminal, characterized in that: include: Low-level components, interactive components, and debug panels; among them, The bottom layer component runs on the simulation terminal and is used to simulate one or more functional components of the large-screen terminal; The interactive component is used to simulate the application to be run on the large-screen terminal and call the underlying component according to the logic of the application; The debugging panel is used to monitor the execution of the application and to set the simulation terminal according to the functional components and version information of the large-screen terminal to facilitate debugging of the application; The application to be run on the large-screen terminal provides an interactive test on the application by accessing a remote URL; or, the application to be run on the large-screen terminal provides an interactive test on the application by calling static resources stored in the simulation terminal.

2. The debugging device according to claim 1, characterized in that: The underlying components include one or more of the following: a camera, a printer, a microphone, a speaker, a browser kernel, and an SDK.

3. The debugging device according to claim 2, characterized in that: The SDK includes one or more of the following: face recognition SDK, voice recognition SDK and gesture recognition SDK.

4. The debugging device according to claim 2, characterized in that: The interactive component determines the browser kernel in the called underlying component according to the version information of the large-screen terminal.

5. The debugging device according to claim 1, characterized in that: The interactive components include applications to be run on the large-screen terminal, JS-SDK, web view controls, and native APIs for calling the underlying components.

6. The debugging device according to claim 1, characterized in that: The debugging panel is also used to set the display effect of the simulation terminal according to the screen size of the large-screen terminal.

7. The debugging device according to any one of claims 1 to 6, characterized in that: The simulation terminal is a mobile terminal.

8. A method for debugging a large-screen terminal using the debugging device according to any one of claims 1 to 7, characterized in that: include: Running the underlying components through the simulated terminal to simulate one or more functional components of the large-screen terminal; Simulate the application to be run on the large-screen terminal through the interactive component, and call the underlying component according to the logic of the application; The execution status of the application is monitored through a debugging panel, and the simulation terminal is set according to the functional components and version information of the large-screen terminal.

9. An electronic device for debugging a large-screen terminal, characterized in that: include: one or more processors; a storage device for storing one or more programs, When the one or more programs are executed by the one or more processors, the one or more processors implement the method according to claim 8.

10. A computer readable medium having a computer program stored thereon, characterized in that: When the program is executed by a processor, the method according to claim 8 is implemented.

Images