Graphical programming software open extension system and method

Abstract

This invention relates to an open extension system and method for graphical programming software, belonging to the field of computer software technology. The system includes: an extension repository, which uses an independently deployed remote service to store and manage approved third-party extension packages and maintain extension metadata mapping files; a client extension management module, which loads the metadata mapping files when the editor starts and initiates extension loading requests on demand in response to user operations; a dynamic loading and security sandbox module, which retrieves extension packages from the extension repository according to loading requests and loads them into a secure, isolated environment for execution; an application programming interface (API) module, which provides standardized API interfaces for third-party extensions; and an aspect-oriented injection engine, which dynamically weaves the functional logic of third-party extensions during editor runtime. This invention overcomes the limitations and closed nature of block-based extensions, achieving secure, efficient, and flexible extension of graphical programming software.

Description

Technical Field

[0001] This invention relates to the field of computer software technology, and in particular to an open extension system and method for graphical programming software. Background Technology

[0002] Existing graphical programming software (such as Scratch) has significant technical shortcomings in terms of scalability, mainly in the following two aspects:

[0003] First, the expansion of the block layer has limitations. Existing solutions typically only support functional expansion blocks pre-built by the software developer (such as music, drawing tools, etc.). Third-party developers find it difficult to freely create and integrate new interactive block modules for their new hardware (such as VR devices, IoT sensors) or network services (such as cloud databases, AI APIs). This severely limits the diversity and development speed of the graphical programming ecosystem.

[0004] Second, the editor itself is closed. If enhancements to the editor's user interface (UI) or functionality are needed (e.g., changing the editor style, adding a debugging toolbar, adding a version management menu, or embedding an AI programming assistant), existing solutions require direct modification of the editor's core project source code. This intrusive modification approach has many drawbacks: it requires developers to have a deep understanding of the complex and massive core code structure, making it highly susceptible to errors and instability; secondly, these modifications are difficult to synchronize with the main version, resulting in high maintenance costs; and more importantly, it lacks an aspect-oriented programming (AOP) mechanism, making it impossible to dynamically inject functional logic without modifying the core code or restarting the application. Summary of the Invention

[0005] To address the aforementioned problems in the prior art, this invention provides an open extension system and method for graphical programming software.

[0006] A graphical programming software open extension system, comprising:

[0007] An extension repository, using a separately deployed remote service, is used to store and manage approved third-party extension packages and maintain extension metadata mapping files;

[0008] The client-side extension management module is used to load the metadata mapping file when the editor starts and to initiate extension loading requests as needed in response to user actions;

[0009] The dynamic loading and security sandbox module is used to retrieve extension packages from the extension repository based on loading requests and load them into a secure, isolated environment for execution.

[0010] The Application Programming Interface (API) module provides standardized API interfaces for third-party extensions.

[0011] An aspect-oriented injection engine is used to dynamically weave in the functional logic of third-party extensions during editor runtime.

[0012] Furthermore, after a third-party developer submits an extension package to the extension repository, the extension repository service module performs automated static scanning and behavior detection on the submitted extension package. After approval, the extension package is packaged using a build tool, and each plugin is encapsulated as an independent object for export. The key name is the plugin's unique identifier, and the value is the function that dynamically imports the plugin's code. After packaging, a metadata mapping file containing all plugin entry information is automatically generated. The metadata mapping file records the mapping relationship between the identifier of each plugin and the corresponding code block.

[0013] Furthermore, the maintenance and extension of the metadata mapping file specifically involves: during the build process, automatically scanning for newly added or modified plugin directories and adding new plugin entries to the exported object according to a preset format; the build system automatically regenerates the complete metadata mapping file to ensure that it contains the latest entry information for all available plugins; when the client detects an update to the metadata mapping file version, it automatically pulls the latest version to achieve dynamic discovery and loading of plugins.

[0014] Furthermore, the dynamic loading and security sandbox module also includes support for obtaining extension code resources from one or more of the following sources: the extension repository service module, the local file system, or directly via a URL network address.

[0015] Furthermore, the dynamic loading and security sandbox module also includes performing a digital signature verification operation before executing the extension package to ensure the integrity and trustworthiness of the extension code resources.

[0016] Furthermore, the system also includes a hot-swap control module, which receives user instructions to enable or disable extensions, and activates or unloads the corresponding extension functions in real time through the AOP injection engine, with the state change taking effect immediately.

[0017] A method for opening and extending graphical programming software includes the following steps:

[0018] S1: Extension Development and Submission: Developers use the standardized API modules to develop extension functions and submit the extension packages to the independent extension repository;

[0019] S2: Extension Review and Metadata Generation: The extension repository service module performs automated static scanning and behavior detection on the submitted extension packages. After the review is passed, it generates or updates a global extension metadata mapping file. The metadata mapping file contains the unique identifier, version number, function description, dependency relationship, loading entry address and digital signature of each extension.

[0020] S3: Editor Startup and Metadata Loading: When the editor core module starts, the client extension management module asynchronously retrieves the metadata mapping file from the extension repository and caches it;

[0021] S4: User Triggering and On-Demand Loading: When a user performs an operation in the editor and triggers a function that requires loading an extension, the client extension management module locates the loading source of the target extension based on the metadata mapping file in the cache.

[0022] S5: Secure Loading and Isolated Execution: The dynamic loading and secure sandbox module obtains the extension package code from the loading source, verifies its digital signature before execution to ensure integrity and trustworthiness of the source, and then loads it into the secure sandbox environment for execution;

[0023] S6: Function Injection and Hot-Swap Control: Through the AOP injection engine, the functional logic of the loaded extensions is dynamically woven into the predetermined cutpoints of the editor's core module; users can enable or disable the loaded extensions in real time, and the state changes take effect immediately through the AOP injection engine without restarting the editor.

[0024] The beneficial effects of this invention are reflected in:

[0025] 1. Significantly improved performance: By loading only the metadata mapping file instead of all extended resources, the editor startup speed is greatly accelerated; the on-demand loading mechanism effectively reduces peak memory usage.

[0026] 2. Security architecture innovation: Through dual isolation (process sandbox / API whitelist), system security is ensured when running third-party extensions, effectively preventing malicious code execution.

[0027] 3. Qualitative leap in ecosystem expansion capabilities: It provides standardized multi-source access methods (local, repository, URL) and AOP hot-plug mechanism, which greatly reduces the threshold and cycle of third-party function development and integration.

[0028] 4. Optimize development and operation efficiency: Standardized APIs reduce repetitive work for developers, and automated review pipelines significantly reduce manual review costs. Attached Figure Description

[0029] Figure 1 This is a system architecture diagram of the present invention.

[0030] Figure 2 This is a flowchart of the method of the present invention. Detailed Implementation

[0031] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0032] Example 1, as Figure 1 As shown, a graphical programming software open extension system includes:

[0033] The extended repository uses a standalone remote service to store and manage audited third-party extension packages and maintain a lightweight metadata mapping file for the extensions.

[0034] The client-side extension management module is used to load the metadata mapping file when the editor starts and to initiate extension loading requests as needed in response to user actions;

[0035] The dynamic loading and security sandbox module is used to retrieve extension packages from the extension repository based on loading requests and load them into a secure, isolated environment for execution.

[0036] The Application Programming Interface (API) module provides standardized API interfaces for third-party extensions, including graphics rendering interfaces, event listening and triggering interfaces, and data persistence storage interfaces.

[0037] An aspect-oriented injection engine is used to dynamically weave in the functional logic of third-party extensions during editor runtime, enabling non-intrusive integration and hot-plugging of functionality.

[0038] In this embodiment, the core function of the metadata mapping file is indexing and locating. It serves as a "navigation map" or "directory" connecting the editor core and the vast ecosystem of third-party extensions. Specifically, each entry in the mapping file contains information that uniquely identifies an extension (such as a unique ID, name, and version number) and, most importantly, location information—the actual storage address of the extension package. When a user needs to load an extension, the editor can precisely determine where to obtain the extension's code resources by querying this mapping file.

[0039] When a third-party developer submits an extension package to the extension repository, the extension repository service module performs automated static scanning and behavior detection on the submitted extension package. After approval, the extension package is packaged using a build tool, and each plugin is encapsulated as an independent object for export. The key name is the unique identifier of the plugin, and the value is the function that dynamically imports the plugin code. After packaging, a metadata mapping file containing all plugin entry information is automatically generated. This file records the mapping relationship between the identifier of each plugin and the corresponding code block.

[0040] The maintenance and update process of the metadata mapping file includes: during the build process, automatically scanning for newly added or modified plugin directories and adding new plugin entries to the exported object according to a preset format; the build system automatically regenerates the complete metadata mapping file, ensuring that it contains the latest entry information for all available plugins; when the client detects an update to the metadata mapping file, it automatically pulls the latest version, enabling dynamic discovery and loading of plugins.

[0041] Accordingly, such as Figure 2 As shown, a graphical programming software open extension method includes the following steps:

[0042] S1: Extension Development and Submission: Developers use the standardized API modules to develop extension functions and submit the extension packages to the independent extension repository;

[0043] S2: Extension Review and Metadata Generation: The extension repository service module performs automated static scanning and behavior detection on the submitted extension packages. After the review is passed, it generates or updates a global extension metadata mapping file. The metadata mapping file contains the unique identifier, version number, function description, dependency relationship, loading entry address and digital signature of each extension.

[0044] S3: Editor Startup and Metadata Loading: When the editor core module starts, the client extension management module asynchronously retrieves the metadata mapping file from the extension repository and caches it;

[0045] S4: User Triggering and On-Demand Loading: When a user performs an operation in the editor and triggers a function that requires loading an extension, the client extension management module locates the loading source of the target extension based on the metadata mapping file in the cache.

[0046] S5: Secure Loading and Isolated Execution: The dynamic loading and secure sandbox module obtains the extension package code from the loading source, verifies its digital signature before execution to ensure integrity and trustworthiness of the source, and then loads it into the secure sandbox environment for execution; this sandbox restricts the extension's access permissions to the local file system, network resources and core code through code isolation and API whitelisting mechanisms;

[0047] S6: Function Injection and Hot-Swap Control: Through the AOP injection engine, the functional logic of the loaded extensions is dynamically woven into the predetermined cutpoints of the editor's core module; users can enable or disable the loaded extensions in real time through the interface, and state changes take effect immediately through the AOP injection engine without restarting the editor.

[0048] In the description of embodiments of the present invention, the terms "first," "second," "third," and "fourth" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first," "second," "third," or "fourth" may explicitly or implicitly include one or more of that feature. In the description of the present invention, unless otherwise stated, "a plurality of" means two or more.

[0049] In the description of embodiments of the present invention, the term "and / or" is used only to describe the relationship between associated objects, indicating that three relationships can exist. For example, A and / or B can represent three cases: A alone, A and B simultaneously, and B alone. Additionally, the character " / " generally indicates that the preceding and following associated objects are in an "or" relationship.

[0050] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A graphical programming software open extension system, characterized in that, Comprising an extension warehouse, using an independently deployed remote service, for storing, managing audited third-party extension packages and maintaining extension metadata mapping files; a client extension management module for loading metadata mapping files when the editor is started, and initiating extension loading requests on demand in response to user operations; a dynamic loading and secure sandbox module for obtaining extension packages in the extension warehouse according to loading requests, and loading them into a secure isolated environment for execution; an application programming interface module for providing standardized API interfaces for third-party extensions; an aspect-oriented injection engine for dynamically weaving the functional logic of third-party extensions during the runtime of the editor.

2. The graphical programming software open extension system of claim 1, wherein, The metadata mapping file is generated after the third-party developer submits the extension package to the extension warehouse. The extension warehouse service module performs automatic static scanning and behavior detection on the submitted extension package. After passing the audit, the extension package is packaged using a build tool. Each plugin is encapsulated as a separate object for export, with the key name being the unique identifier of the plugin and the value being a function that dynamically imports the plugin code. After packaging is complete, a metadata mapping file containing all plugin entry information is automatically generated. The metadata mapping file records the mapping relationship between the identifiers of each plugin and the corresponding code blocks.

3. The open extension system for graphical programming software of claim 1, wherein, The maintenance of the metadata mapping file specifically includes: in the build process, automatically scan the newly added or modified plugin directory, and add the new plugin entry to the export object according to the preset format; the build system will automatically regenerate the complete metadata mapping file to ensure that it contains the latest entry information of all available plugins; the client will automatically pull the latest version when detecting version updates of the metadata mapping file, realizing dynamic discovery and loading of plugins.

4. The graphical programming software open extension system of claim 1, wherein, The dynamic loading and secure sandbox module also includes support for obtaining extension code resources from one or more of the extension warehouse service module, the local file system, or directly through a URL network address.

5. The graphical programming software open extension system of claim 4, wherein, The dynamic loading and secure sandbox module also includes a digital signature verification operation before executing the extension package to ensure the integrity and source trustworthiness of the extension code resources.

6. The open extension system for graphical programming software of claim 1, wherein, It also includes a hot plug control module for receiving user instructions to enable or disable extensions and activating or uninstalling the functions of the corresponding extensions in real time through the AOP injection engine, with the state changes taking effect immediately.

7. A graphical programming software open extension method, applied to the system of any one of claims 1-6, characterized in that, The steps include: S1: Extension development and submission: developers develop extension functions using the standardized API module and submit extension packages to the independent extension warehouse; S2: Extension audit and metadata generation: the extension warehouse service module performs automatic static scanning and behavior detection on the submitted extension package. After passing the audit, a global extension metadata mapping file is generated or updated; the metadata mapping file contains the unique identifier, version number, function description, dependency relationship, loading entry address, and digital signature of each extension; S3: Editor startup and metadata loading: when the editor core module starts, the client extension management module asynchronously obtains the metadata mapping file from the extension warehouse and caches it; S4: User triggers and on-demand loading: When the user operates in the editor and triggers the function of the loaded extension, the client extension management module locates the loading source of the target extension according to the metadata mapping file in the cache; S5: Secure loading and isolated execution: The dynamic loading and secure sandbox module obtains the extension package code according to the loading source, verifies the digital signature before execution to ensure the integrity and source credibility, and then loads it into the secure sandbox environment for running; S6: Function injection and hot plug control: Through the aspect-oriented injection engine, the function logic of the loaded extension is dynamically woven into the predetermined cut point of the editor core module; The user enables or disables the loaded extension in real time, and the state change takes effect immediately through the AOP injection engine without restarting the editor.

Images