Methods and systems for cross-platform mapping and interaction of execution windows of software platforms.

Abstract

This invention provides cross-platform mapping and interaction methods, systems, storage media, electronic devices, and programs for the execution windows of software platforms. [Solution] The mapping and interaction method involves constructing an independent service process on the server side, which provides an HTTP service, communicates in real time with the software platform process to obtain relevant information about the execution window in the software process, sets a buffer area for screenshots for the execution window, sends the saved screenshot image to the client for display, and when the displayed screenshot image triggers, obtains a trigger action through the client, generates a corresponding operation command and sends it to the software process, which then executes the operation of the execution window corresponding to the screenshot image.

Description

Technical Field

[0004] , ,

[0001] This application claims priority based on Chinese Patent Application No. 202510076097.2 filed on January 17, 2025, and Chinese Patent Application No. 202510465550.9 filed on April 15, 2025, and the entire content thereof is incorporated herein by reference.

[0002] The present invention relates to software deployment technology, specifically to cross-platform mapping and interaction methods and systems for the execution windows of software platforms.

Background Art

[0003] Modern software platforms usually include multiple functional windows and user interfaces with different permissions. When executing collaborative simulation tasks, the software platform needs to embed the interface of the collaborative simulation software into the sub-windows of the platform, thereby realizing batch management of these software life cycles. In addition, multiple users need to access the windows of the software platform on different platforms and perform different operations, such as viewing test reports on mobile phones, modifying simulation model parameters on laptops, or modifying calibration parameters on in-vehicle computers. For this, the software platform needs to be able to map and operate multiple windows simultaneously on different platforms.

[0004] The current mainstream solution is to use general-purpose remote control software to enable users to remotely log in to the computer hosting the software platform for viewing and operation. However, this solution has the following drawbacks. 1. To log in, the software platform's execution window must be visible and in the foreground. This requirement means that the software platform's execution window will monopolize the display, obstructing other software running on the desktop and impacting the user experience.

[0005] 2. Interference when multiple users log in simultaneously When multiple users log in simultaneously, the operation of the computer's mouse and keyboard can interfere with each other, easily leading to data entry errors and further impacting work efficiency and accuracy.

[0006] 3. Remote control requires unlocking the computer. The use of remote software typically requires the computer to be unlocked, which increases the risk of data leakage and reduces platform security.

[0007] 4. It is not possible to differentiate authority. Because multiple windows with different permissions exist within a software platform, conventional technologies cannot effectively differentiate between users' permissions, leading to permission conflicts and security risks when users interact with the system.

[0008] Therefore, conventional technologies have a technical problem that cannot be solved by conventional software platforms: the issue of displaying and operating arbitrary execution windows across platforms.

[0009] Please note that the above information disclosed in this background technology section is used solely to understand the background technology that inspired this application, and therefore does not constitute information about prior art. [Overview of the project]

[0010] The object of the present invention is to provide a cross-platform mapping and interaction method and deployment system for the execution windows of a software platform.

[0011] To solve the above technical problems, the present invention provides a method for cross-platform mapping and interaction of execution windows of software platforms. The method is as follows: This involves establishing an independent service process on the server side, wherein the service process provides the Hypertext Transfer Protocol (HTTP) service. The service process communicates in real time with at least one software platform process to obtain relevant information about the execution window in the software process. The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page. When a screenshot image displayed on a web page triggers the service process, it includes obtaining a trigger action through the client, generating a corresponding operation command and sending it to the software process, and performing an operation on the execution window corresponding to the screenshot image through the software process.

[0012] In another embodiment, the present invention provides a cross-platform mapping and interaction system for execution windows of a software platform. The system includes a first computer device and a second computer device.

[0013] The first computer device is configured to include software processes and service processes.

[0014] The service process is configured to provide a Hypertext Transfer Protocol (HTTP) service and to communicate in real time with at least one software platform process to obtain relevant information about the execution window in the software process.

[0015] The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page.

[0016] When a screenshot image displayed on a web page triggers a trigger, the service process obtains the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process executes the operation of the execution window corresponding to the screenshot image.

[0017] The second computer device is configured to include a client.

[0018] The client is configured to receive screenshot images of the execution window sent from the service process, display them through a web page, and send trigger actions for the screenshot images displayed on the web page to the service process.

[0019] In a third aspect, the present invention further provides a readable storage medium in which a computer device readable instruction is stored. When the instruction is executed by at least one processor, the cross-platform mapping and interaction method described above is performed.

[0020] In a fourth aspect, the present invention further provides an electronic device comprising at least one memory storing computer-executable instructions and at least one processor. When the executable instructions are executed by the processor, the processor is caused to perform the cross-platform mapping and interaction method described above.

[0021] In a fifth aspect, the present invention further provides a computer program product including a program or instruction. When the program or instruction is executed on a computer, the cross-platform mapping and interaction method described above is performed.

[0022] A beneficial effect of the present invention is that the cross-platform mapping and interaction method for execution windows of a software platform according to the present invention solves the problem of displaying and operating arbitrary execution windows across platforms, which cannot be solved by conventional software platforms, and new function execution windows designed for the software platform can be remotely shared and controlled without requiring secondary development. By using this method, users can access the specific functions of the software platform through any terminal such as a mobile phone, tablet, or work computer, and in the case of a client terminal, they can participate in controlling the execution window of the corresponding function of the software platform as long as they have a browser, effectively improving the convenience and consistency of access to software platform functions.

[0023] Other features and advantages of the present invention are described in detail in the following specification, and some are evident from the specification or understood by practicing the present invention. The object and other advantages of the present invention are realized and obtained by the structures specifically shown in the specification and drawings.

[0024] In order to more clearly and easily understand the above objects, features, and advantages of the present invention, the following will describe particularly preferred embodiments and, while referring to the accompanying drawings, will explain in detail as follows.

Brief Explanation of Drawings

[0025] In order to more clearly explain the specific embodiments of the present invention or the technical solutions in the prior art, the following will briefly explain the drawings that need to be used in the description of the specific embodiments or the prior art. The drawings in the following description are some embodiments of the present invention, and it is self-evident that those skilled in the art can obtain other drawings based on these drawings without creative effort. [Figure 1] It is a flowchart of a cross-platform mapping and interaction method for an execution window of a software platform according to some embodiments. [Figure 2] It is a schematic diagram of a web page locally generated on a server by a service process in a case according to some embodiments. [Figure 3] It is a configuration page in which a service process in a case according to some embodiments performs real-time communication with a software process based on a local shared memory method. [Figure 4] It is a schematic diagram of a web page including a list of execution windows in a case according to some embodiments. [Figure 5] It is a schematic diagram of a screenshot image of a CAN / CAN FD Transmit execution window displayed on a client web page in a case according to some embodiments. [Figure 6] It is a schematic diagram of the display state of an execution window after a software process in a case according to some embodiments clicks the button in the "Send" column of the first entry "EngineData" in FIG. 5. [Figure 7]This is a schematic diagram of a screenshot image of the CAN / CAN FD Transmit execution window displayed on a client's web page in several embodiment cases. [Figure 8] Figure 7 shows a schematic diagram of an updated screenshot image of the CAN / CAN FD Transmit execution window displayed on the client's web page according to several embodiments. [Figure 9] This is a schematic diagram of the user permission editing function in the remote configuration interface of a software process in several embodiment cases. [Figure 10] This is a schematic diagram of the login page of a client's web page in several embodiments. [Figure 11] This is a schematic diagram of the list of execution windows displayed after the admin user logs in on the client's web page in several embodiment cases. [Figure 12] This is a schematic diagram of the list of execution windows displayed after a user logs in on a client's web page in several embodiment cases. [Figure 13] This is a schematic diagram of the client's web page after a user and an admin user have logged in simultaneously and opened corresponding windows in several embodiment cases. [Figure 14] This is a schematic diagram showing the state after a software process has sequentially executed corresponding user trigger instructions in several embodiment cases. [Figure 15] This is a schematic block diagram of a remote deployment system for user interfaces in a software platform according to several embodiments. [Figure 16] This is a schematic block diagram of an electronic device according to several embodiments. [Figure 17] This is a schematic block diagram of an electronic device according to several embodiments. [Modes for carrying out the invention]

[0026] To further clarify the object, technical solution, and advantages of the embodiments of the present invention, the technical solution of the present invention will be described clearly and completely below in conjunction with the drawings. However, it should be understood that the embodiments described are only some embodiments of the present invention, not all embodiments. All other embodiments obtained by those skilled in the art without creative effort based on the embodiments of the invention are within the scope of protection of the present invention.

[0027] The current mainstream solution involves using general-purpose remote control software to allow users to remotely log in to the computer hosting the software platform and access and manipulate it. However, this solution has the following drawbacks: 1. To log in, the software platform's execution window must be visible and in the foreground. This requirement means that the software platform's execution window will monopolize the display, obstructing other software running on the desktop and impacting the user experience. 2. Interference when multiple users log in simultaneously When multiple users log in simultaneously, the computer's mouse and keyboard operations can interfere with each other, easily leading to data entry errors and impacting work efficiency and accuracy. 3. Remote control requires unlocking the computer. The use of remote software typically requires the computer to be unlocked, which increases the risk of data leakage and reduces platform security. 4. It is not possible to differentiate authority. Because multiple windows with different permissions exist within a software platform, conventional technologies cannot effectively differentiate between users' permissions, leading to permission conflicts and security risks when users interact with the system.

[0028] Therefore, at least one embodiment provides a method for cross-platform mapping and interaction of execution windows of software platforms. The method is This involves establishing an independent service process on the server side, wherein the service process provides the Hypertext Transfer Protocol (HTTP) service. The service process communicates in real time with at least one software platform process to obtain relevant information about the execution window in the software process. The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page. When a screenshot image displayed on a web page triggers the service process, it includes obtaining a trigger action through the client, generating a corresponding operation command and sending it to the software process, and performing an operation on the execution window corresponding to the screenshot image through the software process.

[0029] This software platform's cross-platform mapping and interaction method for execution windows solves the display and operation problems of arbitrary execution windows across platforms that traditional software platforms could not resolve. New function execution windows designed within the software platform can be remotely shared and controlled without requiring secondary development. Using this method, users can access the specific functions of the software platform through any device, such as a mobile phone, tablet, or work computer. In the case of a client device, all that is needed is a browser to participate in controlling the execution window of the corresponding function of the software platform, effectively improving the convenience and consistency of access to software platform functions.

[0030] Hereinafter, various non-limiting embodiments of the embodiments of this disclosure will be described in detail with reference to the drawings.

[0031] As shown in Figure 1, several embodiments provide a method for cross-platform mapping and interaction of execution windows of software platforms. The method includes the following steps: Step S101: An independent service process is established on the server side, and the service process provides a Hypertext Transfer Protocol (HTTP) service. The service process communicates in real time with at least one software platform process to obtain relevant information about the execution window in the software process. Step S102: The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page. Step S103: When a screenshot image displayed on a web page is triggered, the service process obtains the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process executes the operation of the execution window corresponding to the screenshot image.

[0032] Specifically, an independent service process refers to a service process that can run independently. For example, in the case of an executable file with the .exe extension in Windows, it does not need to be loaded by another program to run; it can be executed by double-clicking it.

[0033] The aforementioned display is made on the premise of public access. Public access means that the service process starts a Hypertext Transfer Protocol (HTTP) service and begins intercepting or listening on the HTTP port, allowing other clients to access the web page.

[0034] Specifically, the software process in this embodiment may be, but is not limited to, a proprietary software platform with similar functionality to Mathworks' Matlab software platform, or a proprietary automotive toolchain with similar functionality to Vector's CANoe software.

[0035] In some embodiments, the software process has multiple execution windows. The service process generates a web page containing a list of execution windows based on the relevant information and displays the web page containing the list of execution windows to the client. The selected execution windows are fed back to the service process, which sets up a buffer area for screenshots for each of the selected execution windows, saves a screenshot image of each execution window, sends each screenshot image of each execution window to the client, and then displays it to the client through the corresponding web page.

[0036] The following section will describe in detail, with reference to examples, the cross-platform mapping and interaction methods of the execution window of the software platform according to this embodiment.

[0037] This embodiment provides an example of a cross-platform mapping and interaction method for the execution window of the TSMaster software platform.

[0038] An independent service process, TSMasterServer.exe, is built on the server side, and this service process provides the Hypertext Transfer Protocol (HTTP) service on port 9018. Users can open the web page shown in Figure 2 by opening a browser on any device and entering "http: / / localhost:9018 / " in the address bar.

[0039] The service process communicates in real time with the software process TSMaster64.exe, for example, based on a local shared memory method, but is not limited to this. Figure 3 shows the settings page for the service process based on local shared memory. When the Activate Server switch in these Server Settings is set to On, the service process and the software process can communicate in real time.

[0040] The service process obtains relevant information about the execution window corresponding to the software process TSMaster64 based on real-time communication over shared memory. The software process may have multiple execution windows, in which case the service process generates a web page containing a list of execution windows based on the relevant information and displays this list of execution windows on the web page opened by the client. This list is shown in Figure 4.

[0041] The window list has five window entries, corresponding to five execution windows. To the left of each entry is a checkbox, allowing the user to select the execution window that needs to be displayed by checking the checkbox. For example, if the user checks the second entry, "CAN / CAN FD Transmit," the client will then feed back the execution window corresponding to the second entry, "CAN / CAN FD Transmit," to the service process.

[0042] As shown in Figure 5, the service process sets up a buffer for screenshots for the selected execution window, acquires a screenshot image of the execution window through real-time communication with the software process, and sends the screenshot image to the client for display on the corresponding web page.

[0043] Subsequently, the service process reflects (updates) a screenshot image of the corresponding execution window in the software process on the client's web page in real time. Simultaneously, when the screenshot image displayed on the client's web page is triggered by a user, the service process acquires the user's trigger operation, generates a corresponding operation command, and sends it to the software process, which then executes the operation in the execution window corresponding to the screenshot image. For example, if a user moves the mouse to the button in the "Send" column of the first entry "EngineData" in the "CAN / CAN FD Transmit" window and clicks the mouse, the service process sends the operation command of this mouse click at the trigger position to the software process in real time, which then executes the corresponding mouse operation of the user. As can be seen from Figure 6, in the corresponding execution window of the software process, the button in the "Send" column of the "EngineData" entry changes from a transmission enabled state to a transmission stopped state, indicating that this message is sent periodically by the software process. It can also be seen through the "CAN / CAN FD Trace" window that this message was sent on the bus.

[0044] In some embodiments, the cross-platform mapping and interaction method for the execution window of a software platform further includes the following: The service process requests memory space from the server based on the size information of the execution window, sets an update flag, and stores a screenshot image of the execution window in the requested memory space. The service process retrieves a screenshot image of the execution window from the software process at a first time interval and stores it in a temporary memory space. It compares whether the contents of the requested memory space and the temporary memory space are the same to determine whether the screenshot image of the execution window needs to be updated. If they are not the same, it overwrites the original screenshot image in the requested memory space with the screenshot image of the execution window stored in the temporary memory space. The client retrieves the update flag from the server at a second time interval, and if an update is found, retrieves the screenshot image from the requested memory space from the server and displays the updated screenshot image of the execution window to the client through the corresponding web page.

[0045] Specifically, the aforementioned temporary memory space is used for comparing screenshot images. After the comparison, this space is released, and the contents of the temporary memory space are discarded.

[0046] Specifically, using the example mentioned earlier, we will explain in detail how a service process displays an updated screenshot of the execution window to the client via the corresponding web page when the screenshot image of the execution window changes.

[0047] For example, the user selects the observation execution window "CAN / CAN FD Transmit" from the list of execution windows. The service process then retrieves this execution window checked by the user, requests screenshot information of this execution window from the software process, requests memory space from the server based on the size information of the execution window, sets an update flag, stores the screenshot image of the execution window in the requested memory space, and sends this screenshot image to the client, which then displays the screenshot image of the execution window at the same location in the client's corresponding web page window. The screenshot image is shown in Figure 7.

[0048] During subsequent execution, the service process takes a screenshot of the execution window at the first time interval, stores it in a temporary memory space, and compares whether the contents of the requested memory space and the temporary memory space are the same to determine whether the screenshot of the execution window needs to be updated. If they are not the same, the original screenshot in the requested memory space is overwritten with the screenshot of the execution window stored in the temporary memory space. At the second time interval, the client obtains an update flag from the server, and if an update is found, it obtains the screenshot from the memory space requested by the server and displays it in the corresponding web page window of the client. For example, if the "EngineData" entry in the "CAN / CAN FD Transmit" window is set to send periodically, that is, if the button corresponding to the "Send" column of "EngineData" is in the execution state as shown in Figure 8, when the screenshot image is updated, the client first obtains the update flag, and then obtains and displays the screenshot image.

[0049] In some embodiments, the service process generating a web page containing a list of execution windows based on the relevant information and displaying the web page containing the list of execution windows to a client includes the client sending an access request to the web page to the service process, the service process creating a session module corresponding to the web page based on the access request, and the session module screening the service process's list of execution windows based on authorization information and displaying the screened list of execution windows to the client.

[0050] Using a specific example, we will explain in detail how a service process generates a web page containing a list of execution windows based on the aforementioned relevant information and how to display this web page to the client.

[0051] In the remote configuration interface for the software process, you can check the "Activate User Privileges" function and edit the user list and user privilege control list. Here, in the user list, you can add or remove users and set a password for each user. In the user privilege control list, each execution window is displayed, and on the right side of each execution window, you can check whether each user has access to that window. For example, as shown in Figure 9, you can grant the user only access to "Global Control" and "CAN / CAN FD Trace," while granting the admin user access to all execution windows except "System Messages."

[0052] After the service process establishes a connection with the software process, the service process can obtain permission information for all pre-configured client users. As shown in Figure 10, when a client user logs in through a web page, the service process receives a web page access request from the client, creates a session module corresponding to this web page based on the web page access request, guides the user to the login page, and logs in by entering a username and password on the login page.

[0053] After a user successfully logs in, the session module retrieves the current user's name and permission settings. When logging in as the admin user, the session module screens the list of service process execution windows based on the permission information, and the screened list of execution windows is displayed on the client's web page. Based on the permission settings, the user can access all execution windows except "System Messages". This is shown in Figure 11.

[0054] When logging in as the user, based on the permission settings, the user can only access the "Global Control" and "CAN / CAN FD Trace" windows, where "Global Control" is the window list, as shown in Figure 12.

[0055] In some embodiments, screenshot images displayed on a web page can be triggered simultaneously. Responding to multiple simultaneous trigger actions involves a service process collecting trigger instructions for all session modules and adding them to an execution queue in chronological order, and the service process retrieving the trigger instructions from the execution queue one by one and sending them to a software process in the order they were retrieved to perform the corresponding operations.

[0056] The following section provides a detailed explanation of how multiple trigger actions behave simultaneously, using specific examples.

[0057] For example, as shown in Figure 13, when user user and user admin log in to the server at the same time, user user has the "CAN / CAN FD Trace" window open, and user admin has the "CAN / CAN FD Transmit" window open.

[0058] User `user` checks the "Display messages in chronological order" function in the "CAN / CAN FD Trace" window. User `admin` clicks the "Stop sending all messages" button in the "CAN / CAN FD Transmit" window. Assuming these two user actions occur simultaneously, the service process collects the user trigger commands from these two session modules and adds the user trigger commands to the execution queue in chronological order.

[0059] For example, if a trigger command from user "user" is added to the execution queue first, followed by a trigger command from user "admin," the service process will first retrieve user "user"'s trigger command from the execution queue, then retrieve user "admin"'s trigger command, and send them to the software process in the order they were retrieved to execute the corresponding user trigger command. As a final effect, the "Display messages in chronological order" function will be checked first in the "CAN / CAN FD Trace" window, and then all periodic transmission messages will be stopped in the "CAN / CAN FD Transmit" window. This is shown in Figure 14.

[0060] In some embodiments, the relevant information for the execution window includes the window's location, a unique identifier, a window class name, a window name, and window permissions.

[0061] Specifically, the information related to an execution window includes basic information about the functions and executable windows available on the software platform, such as the window's location, unique identifier, window class name, window name, and window permissions.

[0062] In some embodiments, the service process creates a session module for each web page, and after the web page is closed, the corresponding session module is deleted.

[0063] In some embodiments, the service process and the software platform process communicate in real time using one or more of the following: pipe communication, shared memory communication, socket communication, and message queue communication.

[0064] Specifically, the method of pipe communication includes the following:

[0065] Pipeline creation: Creating a pipeline using a specific system call, with one end used for reading (read end) and the other end for writing (write end). Process association: Associating each process that needs to communicate with the read and write ends of the pipeline. Data writing: The process sending data writes the data to the write end of the pipeline. Data reading: The process receiving data reads the data from the read end of the pipeline. Pipeline closing: After communication is complete, the associated processes close the read and write ends of the pipeline and release the resources.

[0066] Specifically, the method of shared memory communication includes the following:

[0067] Creating shared memory: A single process creates a shared memory region using a system call. Mapping shared memory: Each process that needs to access the shared memory maps it to its own address space using a system call. Data interaction: Synchronization mechanisms such as semaphores and mutual exclusion are used to coordinate access to the shared memory by multiple processes. Demapping: When a process no longer needs to access the shared memory, it demaps it from its address space using a system call. Deleting shared memory: After all processes have finished accessing the shared memory, the shared memory is deleted, freeing up system resources.

[0068] Specifically, the method for socket communication is as follows:

[0069] On a socket communication server, Creating a socket involves binding an address and port using TCP or UDP, requiring TCP to listen for connection requests and establish connections, performing data interaction, and closing the socket.

[0070] In a socket communication client, Creating a socket involves using TCP or UDP, needing to connect to a server for TCP, interacting with data, and closing the socket.

[0071] Specifically, the method of message queue communication includes creating a message queue for storing messages, sending a message that typically contains the message type and specific message content, receiving messages either selectively based on the message type or according to the first-in, first-out principle, performing operations related to the message content, i.e., processing the message, and, after the communication is complete, having the relevant process close the message queue and release the resources, i.e., closing the message queue.

[0072] Furthermore, since prior art can be referenced for the specific implementation of the communication method described above, this embodiment does not modify the communication method itself.

[0073] As shown in Figure 15, some embodiments further provide a cross-platform mapping and interaction system for the execution windows of a software platform. The system includes a first computer device and a second computer device.

[0074] The first computer device is configured to include software processes and service processes.

[0075] The service process is configured to provide a Hypertext Transfer Protocol (HTTP) service and to communicate in real time with at least one software platform process to obtain relevant information about the execution window in the software process.

[0076] The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page.

[0077] When a screenshot image displayed on a web page triggers a trigger, the service process obtains the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process executes the operation of the execution window corresponding to the screenshot image.

[0078] The second computer device is configured to include a client.

[0079] The client is configured to receive screenshot images of the execution window sent from the service process, display them through a web page, and send trigger actions to the service process based on the screenshot images displayed on the web page.

[0080] Here, the specific implementation functions of the software process, service process, and client are realized on the computer device. Specifically, please refer to the details of the cross-platform mapping and interaction methods of the execution windows of the aforementioned software platform. A detailed explanation is omitted here.

[0081] The following describes the electronic devices in the embodiments of this disclosure from the perspective of hardware processing.

[0082] The embodiments of this disclosure do not limit the specific implementation of the electronic device.

[0083] As shown in Figure 16, some embodiments further provide an electronic device. The electronic device includes a processor, a computer-readable storage medium, a communication bus, and a communication interface. The processor, the readable storage medium, and the communication interface communicate with each other via the communication bus. The readable storage medium is used to store a program that performs a cross-platform mapping and interaction method for the execution window of the software platform, the program causing the processor to perform operations corresponding to the cross-platform mapping and interaction method for the execution window of the software platform.

[0084] As shown in Figure 17, some embodiments further provide an electronic device. The electronic device includes a processor, a display that communicates with the processor to display a web page, and a computer-readable storage medium, where the readable storage medium is configured to store instruction programs.

[0085] The processor is configured to execute the instruction program and perform the following operations.

[0086] This involves establishing an independent service process on the server side, where the service process provides the Hypertext Transfer Protocol (HTTP) service.

[0087] The service process communicates in real time with at least one software platform process to obtain relevant information about the execution window in the software process.

[0088] The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page.

[0089] When a screenshot image displayed on a web page triggers a trigger, the service process obtains the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process executes the operation of the execution window corresponding to the screenshot image.

[0090] The display is configured to show a web page containing a list of execution windows and screenshots of the corresponding execution windows.

[0091] In some embodiments, computer devices or industrial computers may be considered a type of electronic device.

[0092] The structures shown in Figures 16 and 17 are not limited to electronic devices and may include fewer or more devices than shown, a combination of some devices, or different device configurations.

[0093] In some embodiments, the communication interface may be a communication interface that can be connected to an external bus adapter, such as an RS232, RS485, USB port, and TYPE port. It may further include a wired or wireless network interface. The network interface may selectively include a wired interface and / or a wireless interface (e.g., a Wi-Fi interface, a Bluetooth interface, etc.) and is typically used to establish a communication connection between the computer device and other electronic devices.

[0094] In some embodiments, the readable storage medium or computer-readable storage medium includes at least one type of memory. The memory includes flash memory, hard disks, multimedia cards, card-type memory (e.g., SD memory), magnetic memory, magnetic disks, optical disks, and the like. In some embodiments, it may be an internal storage unit of a computer device, such as a hard disk of a computer device. In some other embodiments, the memory may be an external storage device of a computer device, such as a plug-in hard disk mounted in a computer device, a Smart Media Card (SMC), a Secure Digital (SD) card, or a Flash Memory Card. Furthermore, the memory may include both internal and external storage devices of a computer device. The memory is used not only to store application software and various data installed in a computer device, such as computer program code, but also to temporarily store data that has already been output or is scheduled to be output.

[0095] In some embodiments, the processor may be a central processing unit (CPU), controller, microcontroller, microprocessor, or other data processing chip used to execute program code stored in memory, such as running a computer program, or to process data.

[0096] In some embodiments, the communication bus may be an input / output bus, which may be a Peripheral Component Interconnect (PCI) bus or an Enhanced Industry Standard Architecture (EISA) bus, etc. The bus may be classified into an address bus, a data bus, a control bus, etc.

[0097] Optionally, the computer device may further include a user interface. The user interface may include input units such as a display and a keyboard, and optionally, the user interface may further include a standard wired interface and a wireless interface. Optionally, in some embodiments, the display may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, and an OLED (Organic Light-Emitting Diode) touch device. Here, the display may be called a display window or display unit for displaying information processed by the computer device and for displaying web pages.

[0098] When the processor executes the program, steps in the embodiment of the cross-platform mapping and interaction method for the execution window of the software platform shown in Figure 1 are performed, for example, the steps shown in Figure 1. Alternatively, when the processor executes the computer program, the functions of the module or unit in each of the embodiments of the device described above are realized.

[0099] Some embodiments further provide a readable storage medium that stores computer-readable instructions causing a cross-platform mapping and interaction method to be executed by at least one processor. The cross-platform mapping and interaction method includes establishing an independent service process on the server side, the service process providing a hypertext transfer protocol (HTTP) service, the service process communicating in real time with at least one software platform process to obtain relevant information about an execution window in the software process, the service process setting a buffer area for screenshots for the execution window, saving a screenshot image of the execution window to the buffer area, and sending the screenshot image of the execution window to a client for display on a web page, and when the screenshot image displayed on the web page is triggered, the service process obtaining a trigger action through the client, generating a corresponding operation instruction and sending it to the software process, and executing an operation on the execution window corresponding to the screenshot image through the software process.

[0100] Some embodiments further provide a computer-readable storage medium that stores computer-readable instructions causing the cross-platform mapping and interaction methods described above to be executed by at least one processor. Specifically, these include the following:

[0101] This involves establishing an independent service process on the server side, where the service process provides the Hypertext Transfer Protocol (HTTP) service.

[0102] The service process communicates in real time with at least one software platform process to obtain relevant information about the execution window in the software process.

[0103] The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page.

[0104] When a screenshot image displayed on a web page triggers a trigger, the service process obtains the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process executes the operation of the execution window corresponding to the screenshot image.

[0105] Please refer to the detailed explanation of cross-platform mapping and interaction methods; the explanation is omitted here.

[0106] Some embodiments further provide a computer program product including a program or instruction. When the program or instruction is executed on a computer, a cross-platform mapping and interaction method is performed. The cross-platform mapping and interaction method includes establishing an independent service process on the server side, wherein the service process provides a hypertext transfer protocol (HTTP) service, the service process communicates in real time with at least one software platform process to obtain relevant information about an execution window in the software process, the service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to a client for display on a web page, and when the screenshot image displayed on the web page is triggered, the service process obtains a trigger action through the client, generates a corresponding operation instruction and sends it to the software process, and the software process performs an operation on the execution window corresponding to the screenshot image.

[0107] Some embodiments further provide computer program products including a computer-readable storage medium. The readable storage medium stores readable program code, which includes instructions that cause at least one processor (one or more computer devices) to perform the following operations:

[0108] This involves establishing an independent service process on the server side, where the service process provides the Hypertext Transfer Protocol (HTTP) service.

[0109] The service process communicates in real time with at least one software platform process to obtain relevant information about the execution window in the software process.

[0110] The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the web page.

[0111] When a screenshot image displayed on a web page triggers a trigger, the service process obtains the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process executes the operation of the execution window corresponding to the screenshot image.

[0112] It should be understood that in some embodiments, the disclosed apparatus and methods may be implemented in other ways. The embodiments of the apparatus described above are illustrative only. For example, the flowcharts and block diagrams in the drawings illustrate feasible system architectures, functions, and operations of apparatus, methods, and embedded program products according to some embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative embodiments, the functions described in a block may be executed in an order different from the order shown in the drawings. For example, two blocks shown consecutively may actually be executed essentially simultaneously, or in reverse order depending on the related functions. It should also be noted that each block in a block diagram and / or flowchart, and combinations of blocks in a block diagram and / or flowchart, may be implemented by a dedicated hardware-based system that performs the specified function or operation.

[0113] Furthermore, in each embodiment of the present invention, each functional module may be integrated to form a single independent part, each module may exist independently, or two or more modules may be integrated to form a single independent part.

[0114] The aforementioned functions may be implemented in the form of software function modules and, if sold or used as independent products, may be stored on a computer-readable storage medium. Based on this understanding, the technical solutions of the present invention are essentially referred to as contributions to the prior art, or as parts of the technical solutions, and may be embodied in the form of a software product, which is stored on a single storage medium and performs all or part of the methods in each embodiment of the present invention.

[0115] By referring to the above-described preferred embodiments of the present invention, those skilled in the art can make various changes and modifications through the above description, without departing from the technical spirit of the invention. The technical scope of the present invention is not limited to the contents of the specification, and its technical scope should be determined based on the claims.

Claims

1. A method for cross-platform mapping and interaction of execution windows of software platforms, This involves establishing an independent service process on the server side, wherein the service process provides the Hypertext Transfer Protocol (HTTP) service. The service process communicates in real time with at least one software platform process to obtain relevant information about the execution window in the software process. The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the client via a web page. A cross-platform mapping and interaction method for execution windows of a software platform, characterized in that when a screenshot image displayed on a web page is triggered, the service process obtains a trigger action through the client, generates a corresponding operation command and sends it to the software process, and performs an operation on the execution window corresponding to the screenshot image through the software process.

2. If the software process has multiple execution windows, the service process may set a buffer area for screenshots for each execution window, save screenshot images of the execution windows to the buffer area, and send the screenshot images of the execution windows to the client for display on the web page. The service process generates a web page containing the list of execution windows based on the related information, and displays the web page containing the list of execution windows to the client. A cross-platform mapping and interaction method for execution windows of a software platform according to claim 1, characterized in that the selected execution windows are fed back to the service process through the client, the service process sets a buffer area for screenshots for each selected execution window, saves a screenshot image of each execution window, sends the screenshot image of each execution window to the client, and then displays it to the client through a corresponding web page.

3. The cross-platform mapping and interaction method for the execution window of the aforementioned software platform is: The service process requests memory space from the server based on the size information of the execution window, sets an update flag, and stores a screenshot image of the execution window in the requested memory space. The service process acquires a screenshot image of the execution window from the software process at a first time interval and stores it in a temporary memory space. The system compares the contents of the requested memory space and the temporary memory space to determine whether they are the same and whether it is necessary to update the screenshot image of the execution window. If they are not the same, the original screenshot image in the requested memory space will be overwritten with the screenshot image of the execution window stored in temporary memory space, The method for cross-platform mapping and interaction of an execution window of a software platform according to claim 2, further comprising the client obtaining an update flag from the server at a second time interval, and if an update is found, obtaining a screenshot image in the memory space requested by the server and displaying the screenshot image of the updated execution window to the client through the corresponding web page.

4. When a screenshot image displayed on a web page triggers a trigger, the service process acquires the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process performs an operation on the execution window corresponding to the screenshot image. The cross-platform mapping and interaction method for the execution window of a software platform according to claim 3, characterized in that the client feeds back a trigger location or trigger command on a web page to the service process, the service process generates a corresponding operation command and sends it to the software process in real time to map the trigger action to the software process, i.e., the software process performs the corresponding operation.

5. The method for cross-platform mapping and interaction of execution windows of a software platform according to claim 4, characterized in that the relevant information for the execution window includes the window's location information, a unique identifier, a window class name, a window name, and window permissions.

6. The service process generates a web page containing a list of execution windows based on the relevant information, and displays the web page containing the list of execution windows to the client. The aforementioned client sends a request to access a web page to the service process, The aforementioned service process creates a session module corresponding to the web page based on the access request, The method for cross-platform mapping and interaction of execution windows of a software platform according to claim 5, characterized in that the session module screens a list of execution windows of service processes based on authorization information and displays the screened list of execution windows to the client.

7. The method for cross-platform mapping and interaction of execution windows of a software platform according to claim 6, characterized in that the service process creates a session module for each web page, and after the web page is closed, the corresponding session module is deleted.

8. Screenshot images displayed on a webpage can be triggered simultaneously. When multiple trigger actions occur simultaneously, The service process collects trigger instructions from all session modules and adds the trigger instructions to the execution queue in chronological order. A cross-platform mapping and interaction method for the execution window of a software platform according to claim 7, characterized in that a service process retrieves trigger instructions one by one from an execution queue and sends them to a software process in the order they were retrieved to perform the corresponding operation.

9. The method for cross-platform mapping and interaction of the execution window of a software platform according to claim 8, characterized in that the service process and the software platform process communicate in real time using one or more of the following: pipe communication, shared memory communication, socket communication, and message queue communication.

10. A cross-platform mapping and interaction system for the execution windows of a software platform, comprising a first computer device and a second computer device, The first computer device is It is configured to include software processes and service processes, The service process is configured to provide a Hypertext Transfer Protocol (HTTP) service and to communicate in real time with at least one software platform process to obtain relevant information about the execution window in the software process. The service process sets a buffer area for screenshots for the execution window, saves a screenshot image of the execution window to the buffer area, and sends the screenshot image of the execution window to the client for display on the client via a web page. When a screenshot image displayed on a web page is triggered, the service process obtains the trigger action through the client, generates a corresponding operation command and sends it to the software process, and the software process executes the operation of the execution window corresponding to the screenshot image. The second computer device is configured to include a client, A cross-platform mapping and interaction system for execution windows of a software platform, characterized in that the client is configured to receive a screenshot image of the execution window sent from the service process, display it through a web page, and send a trigger action of the screenshot image displayed on the web page to the service process.

11. A computer-readable storage medium that stores instructions readable by a computer device, wherein when the instructions are executed by at least one processor, the cross-platform mapping and interaction method according to any one of claims 1 to 9 is performed.

12. An electronic device comprising at least one memory storing computer-executable instructions and at least one processor, wherein when the executable instructions are executed by the processor, the processor is caused to execute the cross-platform mapping and interaction method described in any one of claims 1 to 9.

13. A program for causing a computer to perform the cross-platform mapping and interaction method described in any one of claims 1 to 9.

Images