Software cross-platform development and operation method

Abstract

The invention discloses a software cross-platform development and operation method. The method comprises the following steps: providing a set of universal software codes capable of adapting to different operating systems and hardware architectures; respectively compiling and generating adaptive versions in various compiling environments through a cloud compiling cluster, and dynamically distributing the matched versions according to a user side environment; and the user side runs the version through a mixed code engine, supports direct analysis, compilation running after conversion into a C language or Java and compilation into machine code running, and realizes cross-platform running in combination with a dynamic library. Through the dynamic adaptation mechanism of the cloud compiling cluster, the modular design of the universal software codes and the multi-mode support of the mixed code engine, the target of one-time development and multi-platform operation is achieved, and the operation efficiency and platform compatibility are improved. All the modules are optimized cooperatively, so that the overall performance of the system is remarkably superior to that of the prior art, the development complexity and resource waste are reduced, and meanwhile, the developer efficiency and the user side experience are improved.

Description

Technical Field

[0001] The present invention relates to the technical field of software cross-platform development and operation, and particularly to a method for software cross-platform development and operation. Background Art

[0002] With the rapid development of computer technology, cross-platform software development has gradually become an important field, widely used in software systems that need to run on different operating systems and hardware architectures. Its working principle is usually to develop a set of code that can run on multiple platforms (such as Windows, Linux, macOS, Android, and iOS), thereby reducing the workload of repeated development and improving development efficiency. However, there are significant technical challenges in achieving this goal. In the prior art, the following two mainstream methods are usually adopted in the industry to achieve cross-platform development:

[0003] 1. Use a unified runtime environment or framework. This method provides a unified abstract runtime environment (such as Electron, Flutter, etc.) for different platforms, enabling software code to run in this runtime to achieve cross-platform compatibility. Its principle is to shield the underlying system differences in the runtime. Developers only need to write the code once and can run it on different platforms. However, in this method, the runtime environment is usually very large, which easily leads to software performance degradation, especially on resource-constrained devices (such as mobile or embedded devices), and an additional intermediate layer needs to be introduced for platform adaptation, which may increase the memory occupancy and startup time of the runtime and reduce the user experience.

[0004] 2. Multi-platform porting based on source code. This method solves the cross-platform running problem by separately writing adaptation code for each platform. For example, developers need to re-implement part of the code logic for the operating system interfaces of different platforms to ensure the correct operation of the software. However, in this way, since developers need to understand the characteristics and development toolchains of each platform, the development cost increases significantly, and with version iteration, the software maintenance cost also increases exponentially. Especially when it is necessary to synchronously update on multiple platforms, compatibility problems are very likely to occur.

[0005] To avoid the above problems, a cloud compilation solution has also been proposed in the industry, where the code is compiled into multi-platform versions in the cloud and then distributed to the client. Although this method solves some cross-platform adaptation problems, there are still the following defects: for example, the compilation process lacks flexibility, and developers cannot customize the adapted version according to their needs, resulting in insufficient support for some special environments (such as customized operating systems or non-mainstream hardware architectures); the client cannot dynamically select the optimal compilation version at runtime, and compatibility problems may still occur due to mismatches; during the running stage, the dynamic nature of code adaptation is insufficient, and the execution strategy cannot be flexibly adjusted according to the actual environment, which may affect the performance.

[0006] Therefore, how to implement a cross-platform software development method that can compile efficiently, adapt flexibly, and run dynamically, which can not only significantly improve the running performance but also reduce the development and maintenance costs, has become the technical problem to be solved by the present invention. Summary of the Invention

[0007] The technical problem solved by the present invention is to provide a software cross-platform development and running method to address the problems of low efficiency, serious performance loss, and lack of flexibility in existing cross-platform development as described in the above background technology, aiming at the defects existing in the above prior art.

[0008] To solve the above technical problems, the technical solution adopted by the present invention is as follows:

[0009] A software cross-platform development and running method, comprising the following steps:

[0010] Step 1, providing a set of general software code;

[0011] Step 2, based on a cloud compilation cluster, compiling the software code in multiple compilation environments respectively to generate multiple versions adapted to different operating systems and hardware architectures, where the compilation environments include:

[0012] Different operating system environments: Windows, Linux, macOS, Android, iOS;

[0013] Different hardware architecture environments: X86_32, X86_64, ARM_32, ARM_64;

[0014] Step 3, when the software is installed on the user side, by detecting the system environment where it is located, including the operating system and the hardware architecture, dynamically identifying the required version;

[0015] Step 4, downloading the software version that matches the user side system environment from the cloud compilation cluster;

[0016] Step 5, run the software version through the Hybrid Code Engine, where the engine selects different code execution methods according to the operating environment, including direct parsing and running, compiling and running after converting to C language, compiling to machine code and running, or converting to Java and then compiling and running;

[0017] Step 6, during the software running process, call a set of dynamic libraries to support the cross-platform running, and the dynamic libraries include:

[0018] librose.so: responsible for system compatibility recognition;

[0019] libsense.so: responsible for compilation platform support;

[0020] libobject.so: responsible for runtime operation support.

[0021] As a further solution of the present invention, the cloud compilation cluster supports the following compilation rules:

[0022] When the user uploads the code, it is possible to specify the compilation scope, including full environment compilation, partial environment compilation or skipping compilation;

[0023] In the case of skipping compilation, the user uploads a locally compiled software package and specifies the operating system and hardware architecture it applies to.

[0024] As a further solution of the present invention, when the user terminal detects the system environment, it uses the dynamic library librose.so to realize the function of dynamically matching and adapting versions by automatically identifying the operating system version and hardware architecture of the user terminal.

[0025] As a further solution of the present invention, the Hybrid Code Engine supports the following dynamic selection of running modes:

[0026] Direct parsing and running of OSE code;

[0027] Compiling and running after converting OSE code to C language;

[0028] Directly compiling OSE code to machine code and running;

[0029] Compiling and running after converting OSE code to Java code.

[0030] As a further solution of the present invention, the dynamic library librose.so is used to load the required library files during runtime to shield the differences between different operating systems and hardware architectures, so that the software can run in a consistent manner on different platforms.

[0031] As a further solution of the present invention, the dynamic library libsense.so is used to support cross-platform compilation platform functions, including automatically selecting the target compilation environment and optimizing the compilation process.

[0032] As a further solution of the present invention, the dynamic library libobject.so provides runtime support functions, including memory management, encapsulation of operating system call interfaces, and resource scheduling optimization.

[0033] As a further solution of the present invention, the method further includes:

[0034] Software modular development, where each module supports independent compilation configurations, including specifying the compilation method as direct parsing, compilation after conversion to C language, or direct compilation to machine code;

[0035] After the module is compiled, it is called through a unified interface method, where the Solex interface is used to load the dynamic library of the corresponding module.

[0036] As a further solution of the present invention, the general software code refers to a set of source codes that can be adapted and run on different operating systems and hardware architectures, including but not limited to core business logic codes, abstract interface codes, and adaptation module codes.

[0037] Compared with the prior art, the beneficial effects of the present invention are:

[0038] 1. Through the cloud compilation cluster technology, the present invention performs targeted compilation on the same set of general software codes in different compilation environments and dynamically distributes the adapted versions according to the user-side environment. This mechanism avoids the redundant design of traditional cross-platform tools that require a built-in unified runtime, greatly improves the running efficiency, and saves user-side resources at the same time. In the prior art, similar solutions can only achieve batch compilation and cannot achieve dynamic and precise matching, making it difficult to balance efficiency and compatibility.

[0039] 2. Through the cooperation of abstract interfaces and adaptation modules, the general software code has high flexibility and scalability. The core business logic is completely decoupled from platform-related functions, shielding the underlying differences, thus achieving the goal of "write once, run on multiple platforms". Especially the dynamic call ability of the adaptation layer supports the expansion requirements of future platforms and avoids the limitations of traditional cross-platform tools that need to be re-developed when adding new platform support. The adaptation module collaborates with the cloud compilation cluster to make the development and running processes more closely integrated, improving the overall efficiency of the system.

[0040] 3. The hybrid code engine provides multiple execution modes, including direct parsing and running, compiling and running after conversion to C language, compiling to machine code for running, and running after conversion to Java code. Compared with tools with a single execution mode in the prior art, the present invention can dynamically select the optimal running mode according to the characteristics of the target platform, achieving the best balance between performance and compatibility. At the same time, combined with the function support of dynamic libraries, the required modules can be flexibly loaded during runtime, further enhancing the runtime efficiency and adaptability.

[0041] Additional aspects and advantages of the present invention will be given in part in the following description, become apparent in part from the following description, or be learned through the practice of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the following will briefly introduce the drawings required for use in the description of the embodiments or the prior art. Obviously, the drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can be obtained based on these drawings.

[0043] Figure 1 It is a layered solution diagram for software cross-platform compatibility of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0044] The following will clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, rather than all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts belong to the scope of protection of the present invention.

[0045] Please refer to Figure 1 , in an embodiment of the present invention, a software cross-platform development and running method includes the following steps:

[0046] Step 1, providing a set of general software code;

[0047] Step 2, based on a cloud compilation cluster, respectively compiling the software code in multiple compilation environments to generate multiple versions adapted to different operating systems and hardware architectures, where the compilation environments include:

[0048] Different operating system environments: Windows, Linux, macOS, Android, iOS;

[0049] Different hardware architecture environments: X86_32, X86_64, ARM_32, ARM_64;

[0050] Step 3, when the software is installed on the client side, the required version is dynamically identified by detecting the system environment, including the operating system and hardware architecture, where the client is located;

[0051] Step 4, according to the system environment of the client side, download the software version that matches it from the cloud compilation cluster;

[0052] Step 5, run the software version through the Hybrid Code Engine, where the engine selects different code execution methods according to the running environment, including direct parsing and running, compiling and running after converting to C language, compiling to machine code and running, or converting to Java and then compiling and running;

[0053] Step 6, during the running of the software, a set of dynamic libraries are called to support the cross-platform running, and the dynamic libraries include:

[0054] librose.so: responsible for system compatibility identification;

[0055] libsense.so: responsible for compilation platform support;

[0056] libobject.so: responsible for runtime operation support.

[0057] As a further solution of the present invention, the cloud compilation cluster supports the following compilation rules: when the user uploads the code, the compilation scope can be specified, including full environment compilation, partial environment compilation or skipping compilation;

[0058] In the case of skipping compilation, the user uploads the locally compiled software package and specifies the operating system and hardware architecture it applies to. When the client side detects the system environment where it is located, the dynamic library librose.so is used to realize the function of dynamically matching and adapting the version by automatically identifying the operating system version and hardware architecture of the client side; the Hybrid Code Engine supports the following dynamic selection of running methods: directly parsing and running the OSE code; compiling and running the OSE code after converting it to C language; directly compiling the OSE code into machine code and running; converting the OSE code into Java code and then compiling and running.

[0059] The dynamic library librose.so is used to load the required library files at runtime to shield the differences between different operating systems and hardware architectures, so that the software can run in a consistent manner on different platforms; the dynamic library libsense.so is used to support the cross-platform compilation platform function, including automatically selecting the target compilation environment and optimizing the compilation process; the dynamic library libobject.so provides runtime support functions, including memory management, encapsulation of operating system call interfaces and resource scheduling optimization.

[0060] As a further solution of the present invention, the method further includes: software modular development, where each module supports independent compilation configuration, including specifying the compilation method as direct parsing, compilation after conversion to C language, or direct compilation into machine code; after the module is compiled, it is called through a unified interface method, where the Solex interface is used to load the dynamic library of the corresponding module; the general software code refers to a set of source codes that can be adapted and run on different operating systems and hardware architectures, including but not limited to core business logic code, abstract interface code, and adaptation module code.

[0061] See Figure 1 , which shows a hierarchical model for solving compatibility problems in cross-platform software development. Different technical problems are solved sequentially from the bottom layer to the top layer: Layer 1: Solve the cross-platform support problem, including compatibility with mainstream operating systems (such as Windows, macOS, Linux, Android, iOS, etc.). Layer 2: Further solve the detailed problems of platform support, providing support for specific versions of different operating systems and hardware architectures. Layer 3: Focus on browser support to ensure that the software runs properly in common browsers (such as Chrome, Safari, Edge, Firefox). Layer 4: Optimize the experience for browser kernel and standard differences to ensure compatibility. Layer 5: Ensure the stability of upper-layer applications without relying on specific features of the operating system or browser. Layer 6: Finally, achieve a seamless user experience, shielding underlying platform differences and solving the problems of system and browser dependencies.

[0062] Example 1:

[0063] In enterprise application development, it is often necessary to develop a management system (such as an ERP system), which needs to support multiple operating systems (such as Windows, Linux, macOS) and hardware architectures (such as X86_64, ARM_64), and at the same time be compatible with mobile platforms (such as Android and iOS) to meet the usage requirements of different terminal devices. In the prior art, developers usually need to develop or port code separately for each platform, which not only results in a long development cycle and high maintenance cost, but also has a difficult-to-balance problem between performance optimization and cross-platform compatibility. Based on the technical solution of the present invention, this example provides an efficient development and operation method for a multi-platform environment through the collaborative work of a cloud compilation cluster, general software code, and a hybrid code engine, effectively solving the above problems.

[0064] In the specific implementation process, developers first write a set of general software code. This code is based on modular design and includes a core business logic module, an abstract interface module, and an adaptation module. The core business logic module is independent of the specific characteristics of any platform and implements the main logic of business functions, such as order management and inventory tracking functions in an ERP system. The abstract interface module provides standardized interface definitions, shielding the differences in underlying systems and hardware architectures. Developers complete the implementation of business logic by calling these interfaces. The adaptation module targets the characteristics of different operating systems and hardware architectures and implements the specific adaptation of underlying APIs or system functions. For example, it calls Win32API on the Windows platform, POSIX interfaces on the Linux platform, and optimizes the floating-point operation logic on the ARM architecture.

[0065] Through the cloud compilation cluster, this general code is separately compiled into versions adapted to each platform in different compilation environments in the cloud. For example, the cloud compilation cluster generates an adapted executable file in the X86_64 architecture environment supporting Windows, and at the same time generates an adapted App file package in the ARM_64 environment supporting iOS, and supports users to customize compilation rules, such as choosing full-environment compilation or partial-environment compilation. After compilation, the cloud compilation cluster will store the generated adapted versions in the distribution center and wait for dynamic download by the user side.

[0066] When the user side installs the software, it first identifies the operating system and hardware architecture through the dynamic library librose.so. For example, it detects that the running environment is a Linux system based on the ARM_64 architecture. Subsequently, the user side will automatically download the compiled version that matches its environment from the cloud distribution center, avoiding failure situations caused by version mismatch during the installation process. After installation, the user starts the software through the hybrid code engine, and the hybrid code engine selects the optimal execution method according to the performance characteristics of the user device. For example, in a high-performance desktop device, the hybrid code engine selects the mode of directly compiling into machine code for operation to obtain the best performance; while in a resource-constrained mobile device, it selects the mode of directly parsing the code for operation to save memory resources and startup time.

[0067] During the running process, the system realizes the support for cross-platform operation through dynamic libraries. Among them, librose.so is responsible for loading dynamic library files adapted to different platforms at runtime, shielding the underlying system differences; libsense.so provides support for the cloud compilation platform and dynamically parses compilation information when reloading modules is required; libobject.so is responsible for memory management during runtime and encapsulation of operating system calls. For example, when the ERP system needs to load the inventory management module, librose.so first checks the current running environment and calls the corresponding module dynamic library to ensure the normal operation of the function, without the need for developers to handle the underlying loading logic separately for each platform.

[0068] Take a typical cross-platform application scenario as an example: A chain retail enterprise needs to use an ERP system to manage various devices across the country, including office computers with Windows systems, mobile terminals with Android systems, and customized embedded devices based on the ARM architecture. Through the technical solution of the present invention, the developer of the ERP system only needs to write a set of general code and compile it once in the cloud to generate versions adapted to all platforms. When the system is installed, it automatically identifies the device environment and downloads the corresponding version. During operation, it selects the optimal execution mode through a hybrid code engine. In actual use, the ERP system can run at the highest performance on office computers and also run smoothly on resource-constrained embedded devices, solving the problems of high cost and low efficiency caused by repeated development and adaptation in traditional solutions.

[0069] Through this embodiment, the present invention achieves the following remarkable technical effects: First, developers do not need to develop separately for each platform, significantly reducing the development workload and the complexity of maintenance; Second, the cloud compilation cluster combined with the dynamic distribution mechanism ensures that the user side can install an efficient version that perfectly matches the device environment, avoiding compatibility problems; Third, the hybrid code engine combined with dynamic library support provides optimal performance and resource utilization in different operating environments, enhancing the user experience. The collaborative work of the above technical solutions greatly improves the efficiency of cross-platform development and operation, breaks through the limitations of the prior art, and has significant technical progressiveness and practical application value.

[0070] Example 2:

[0071] In the development scenario of a smart home system, different home devices often run on multiple operating systems (such as Linux, Android, RTOS) and hardware architectures (such as X86_64, ARM_32, ARM_64), such as smart refrigerators, smart speakers, and home central control screens. These devices need to be controlled through a unified software management platform. Traditional development methods require separately adapting the operating system and hardware architecture for each device, and developers need to spend a lot of time dealing with underlying compatibility problems, resulting in low development efficiency, high maintenance costs, and slow updates. Based on the technical solution of the present invention, these problems are solved through the collaborative work of the cloud compilation cluster, general software code, and dynamic loading mechanism.

[0072] In this embodiment, the developer first writes a set of general software code. The code is designed according to a modular structure and is divided into a core business logic module, an abstract interface module, and an adaptation module. For example, the core business logic module is responsible for the core functional logic of smart home devices, such as device status monitoring, data collection and analysis; the abstract interface module shields the differences between the underlying operating system and hardware and provides a unified interface for the business logic to call; the adaptation module implements specific function adaptation for the operating systems and hardware architectures of various devices. For example, in Linux devices, system-level APIs are called to obtain device status, and in RTOS devices, sensor data is read through hardware interrupts.

[0073] The developer compiles the general software code in different compilation environments in the cloud through a cloud compilation cluster to generate multiple versions adapted to smart speakers, refrigerators, and home control screens. For example, the compilation cluster generates a version of the smart speaker in the Linux environment of the X86_64 architecture, a version of the smart refrigerator in the RTOS environment of the ARM_64 architecture, and a version of the home control screen in the Android environment of the ARM_32 architecture. The developer can choose full-environment compilation or targeted compilation according to the differences of the devices. After all versions are compiled, they are stored in the cloud distribution center.

[0074] During actual deployment, each smart device detects its own operating system version and hardware architecture through the dynamic library librose.so. For example, when the smart refrigerator detects that it is running in the RTOS environment of the ARM_64 architecture, the device will automatically download the compiled version that matches it from the cloud distribution center. Subsequently, through the dynamic loading mechanism, the device starts the adapted version and calls libsense.so to parse the runtime configuration to optimize the device resource occupancy. Finally, libobject.so is loaded to provide runtime support functions, including memory management and encapsulation of device I / O interfaces, to ensure the stable operation of the device in different environments.

[0075] During the operation of the smart home system, the user sends instructions through the home central control screen, and the system passes the instructions to the smart refrigerator and the smart speaker through the hybrid code engine. On the smart speaker with relatively sufficient resources, the hybrid code engine chooses to directly compile the code into machine code for operation to improve audio processing performance; while on the resource-constrained smart refrigerator, the hybrid code engine chooses to directly parse the code for operation to reduce memory occupancy. In this process, the dynamic loading mechanism of the adaptation module ensures that each module can flexibly call the underlying interfaces to complete tasks.

[0076] Through this embodiment, the technical solution of the present invention achieves the following remarkable technical effects: developers only need to write the code once, and complete multi-platform adaptation through the cloud compilation cluster, avoiding the high costs of repeated development and maintenance; when the device is running, it can automatically download and load the version most suitable for its environment, ensuring the high efficiency and compatibility of the system; combined with the operation mode selection of the hybrid code engine and the loading mechanism of dynamic libraries, each device can operate in the optimal mode according to the resource status, ensuring both high performance and saving device resources. The above technical solution breaks through the bottleneck of multi-platform adaptation in traditional smart home development, providing an efficient, flexible and stable solution for the industry.

[0077] In the present invention, unless otherwise clearly defined and limited, terms such as "installation", "setting", "connection", "fixation", "swivel connection" and the like shall be understood in a broad sense. For example, it can be a fixed connection, a detachable connection, or integrated; it can be a mechanical connection or an electrical connection; it can be directly connected or indirectly connected through an intermediate medium, and it can be the internal communication of two components or the interaction relationship between two components. Unless otherwise clearly defined, for those of ordinary skill in the art, the specific meanings of the above terms in the present invention can be understood according to specific circumstances.

[0078] For those skilled in the art, it is obvious that the present invention is not limited to the details of the above exemplary embodiments, and without departing from the spirit or basic characteristics of the present invention, the present invention can be implemented in other specific forms. Therefore, from any point of view, the embodiments should be regarded as exemplary and non-limiting. The scope of the present invention is defined by the appended claims rather than the above description. Therefore, it is intended to embrace all changes falling within the meaning and scope of the equivalent elements of the claims in the present invention.

Claims

1. A software cross-platform development and operation method, characterized in that: The following steps are involved: Step 1, provide a set of common software codes; Step 2: Based on the cloud compilation cluster, the software code is compiled in multiple compilation environments to generate multiple versions adapted to different operating systems and hardware architectures, wherein the compilation environment includes: Different operating system environments: Windows, Linux, macOS, Android, iOS; Different hardware architecture environments: X86_32, X86_64, ARM_32, ARM_64; Step 3: When the user installs the software, the required version is dynamically identified by detecting the system environment, including the operating system and hardware architecture; Step 4: Download the matching software version from the cloud compilation cluster according to the user's system environment; Step 5, running the software version through a Hybrid Code Engine, wherein the engine selects different code execution modes according to the operating environment, including direct parsing and running, converting to C language and then compiling and running, compiling to machine code and running, or converting to Java and then compiling and running; Step 6: During the software operation, a set of dynamic libraries are called to support the cross-platform operation, and the dynamic libraries include: librose.so: responsible for system compatibility identification; libsense.so: responsible for compiling platform support; libobject.so: responsible for runtime operation support.

2. A software cross-platform development and operation method according to claim 1, characterized in that: The cloud compilation cluster supports the following compilation rules: When users upload code, they can specify the compilation scope, including full environment compilation, partial environment compilation, or skip compilation; In the case of skipping compilation, the user uploads a locally compiled software package and specifies the operating system and hardware architecture for which it is applicable.

3. A software cross-platform development and operation method according to claim 1, characterized in that: When the user terminal detects the system environment in which it is located, the dynamic library librose.so is used to realize the function of dynamically matching the adaptation version by automatically identifying the operating system version and hardware architecture of the user terminal.

4. A software cross-platform development and operation method according to claim 1, characterized in that: The HybridCode Engine supports dynamic selection of the following operation modes: OSE code is directly parsed and run; The OSE code is converted into C language and then compiled and run; OSE code is directly compiled into machine code and runs; The OSE code is converted into Java code and then compiled and run.

5. A software cross-platform development and operation method according to claim 1, characterized in that: The dynamic library librose.so is used to load the required library files at runtime to shield the differences between different operating systems and hardware architectures, so that the software can run in a consistent manner on different platforms.

6. A software cross-platform development and operation method according to claim 1, characterized in that: The dynamic library libsense.so is used to support cross-platform compilation platform functions, including automatic selection of target compilation environment and optimization of compilation process.

7. A software cross-platform development and operation method according to claim 1, characterized in that: The dynamic library libobject.so provides runtime support functions, including memory management, encapsulation of operating system call interfaces, and resource scheduling optimization.

8. A software cross-platform development and operation method according to claim 1, characterized in that: The method further comprises: Modular software development, where each module supports independent compilation configuration, including specifying the compilation method as direct parsing, converting to C language and then compiling, or directly compiling to machine code; After the modules are compiled, they are called through a unified interface, in which the dynamic library of the corresponding module is loaded using the Solex interface.

9. A software cross-platform development and operation method according to claim 1, characterized in that: The general software code refers to a set of source code that can be adapted to run on different operating systems and hardware architectures, including but not limited to core business logic code, abstract interface code and adaptation module code.

Images