Information processing method for interface construction, interface construction method, and related apparatus

Abstract

The present disclosure relates to the technical field of computers, and relates to an information processing method for interface construction, an interface construction method, a related apparatus, an electronic device, a computer readable storage medium, and a computer program product. The information processing method for interface construction comprises: receiving a first instruction from a target interface module developed by a user, the first instruction being used for acquiring target information related to construction of a target interface; converting the first instruction into a second instruction supported by a target source code; acquiring the target information from the target source code on the basis of the second instruction; and sending the acquired target information to the target interface module, so that the target interface module constructs the target interface on the basis of the target information. According to the present disclosure, the secondary development efficiency of interfaces can be improved, thereby reducing the maintenance costs.

Description

Information processing method for interface construction, interface construction method and related device

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application is based on and claims priority to an application with Chinese application number 202410309203.2, application date March 18, 2024, and title “Information processing method, interface construction method and related device for interface construction”. The disclosed content of the Chinese application is hereby introduced as a whole into this application. Technical Field

[0003] The present disclosure relates to the field of computer technology, and in particular to an information processing method for interface construction, an interface construction method and related devices, electronic equipment, a computer-readable storage medium, and a computer program product. Background Art

[0004] The front-end interface provided by some completed source codes (ie source codes) is usually an integral product.

[0005] In the related art, developers adjust the front-end interface by directly modifying the source code to rebuild the front-end interface required by the developers.

[0006] Summary of the Invention

[0007] This summary is provided to briefly introduce concepts that will be described in detail in the detailed description below. This summary is not intended to identify key features or essential features of the claimed technical solution, nor is it intended to limit the scope of the claimed technical solution.

[0008] According to some embodiments of the present disclosure, there is provided an information processing method for interface construction, comprising: receiving a first instruction from a target interface module developed by a user, the first instruction being used to obtain target information related to constructing a target interface; converting the first instruction into a second instruction supported by a target source code; obtaining the target information from the target source code according to the second instruction; and sending the obtained target information to the target interface module so that the target interface module constructs the target interface according to the target information.

[0009] According to some embodiments of the present disclosure, an interface construction method is provided, which is executed by a target interface module developed by a user. The interface construction method includes: sending a first instruction based on an arbitrary programming language to an intermediate layer, the first instruction being used to obtain target information related to constructing a target interface from a target source code; receiving the target information recognizable by the arbitrary programming language from the intermediate layer; and constructing the target interface using the target information recognizable by the arbitrary programming language.

[0010] According to some embodiments of the present disclosure, there is provided an information processing device for interface construction, comprising: a receiving module configured to receive a first instruction from a target interface module developed by a user, wherein the first instruction is used to obtain target information related to constructing a target interface; a conversion module configured to convert the first instruction into a second instruction supported by a target source code; an acquisition module configured to obtain the target information from the target source code according to the second instruction; and a sending module configured to send the obtained target information to the target interface module, so that the target interface module constructs the target interface according to the target information.

[0011] According to some embodiments of the present disclosure, an interface construction device is provided, including: a target interface module developed by a user, configured to: send a first instruction based on an arbitrary programming language to an intermediate layer, the first instruction being used to obtain target information related to constructing a target interface from a target source code; receive the target information recognizable by the arbitrary programming language from the intermediate layer; and construct the target interface using the target information recognizable by the arbitrary programming language.

[0012] According to some embodiments of the present disclosure, an electronic device is provided, comprising: a memory; and a processor coupled to the memory, wherein the processor is configured to execute the information processing method or interface construction method of any embodiment described in the present disclosure based on instructions stored in the memory.

[0013] According to some embodiments of the present disclosure, a computer-readable storage medium is provided, on which a computer program is stored. When the program is executed by a processor, the information processing method or interface construction method of any embodiment described in the present disclosure is executed.

[0014] According to some embodiments of the present disclosure, a computer program product is provided. When the computer program product is run on a computer, the computer is enabled to implement an information processing method or an interface construction method.

[0015] Other features, aspects and advantages of the present disclosure will become apparent from the following detailed description of exemplary embodiments of the present disclosure with reference to the accompanying drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] The preferred embodiments of the present disclosure are described below with reference to the accompanying drawings. The drawings described herein are used to provide a further understanding of the present disclosure. Each of the drawings, together with the following detailed description, is included in this specification and forms a part of the specification to explain the present disclosure. It should be understood that the drawings described below only relate to some embodiments of the present disclosure and do not constitute a limitation of the present disclosure. In the drawings:

[0017] FIG1 shows a flow chart of an information processing method for interface construction according to some embodiments of the present disclosure;

[0018] FIG2 shows a flow chart of an interface construction method according to some embodiments of the present disclosure;

[0019] FIG3 is a schematic diagram showing the interaction between the target interface module and the SDK according to some embodiments of the present disclosure;

[0020] FIG4 shows a block diagram of an information processing device for interface construction according to some embodiments of the present disclosure;

[0021] FIG5 is a block diagram illustrating an interface construction device according to some embodiments of the present disclosure;

[0022] FIG6 shows a block diagram of an electronic device according to some embodiments of the present disclosure;

[0023] FIG7 shows a block diagram of an electronic device according to some further embodiments of the present disclosure.

[0024] It should be understood that, for ease of description, the dimensions of the various parts shown in the drawings are not necessarily drawn to scale. The same or similar reference numerals are used throughout the drawings to indicate the same or similar parts. Therefore, once an item is defined in one drawing, it may not be discussed further in subsequent drawings. DETAILED DESCRIPTION

[0025] The following will be combined with the accompanying drawings in the embodiments of the present disclosure to clearly and completely describe the technical solutions in the embodiments of the present disclosure. However, it is obvious that the embodiments described are only some embodiments of the present disclosure, rather than all embodiments. The following description of the embodiments is actually only illustrative and is in no way intended to limit the present disclosure and its application or use. It should be understood that the present disclosure can be implemented in various forms and should not be construed as being limited to the embodiments described herein.

[0026] It should be understood that the various steps described in the method embodiments of the present disclosure can be performed in different orders and / or performed in parallel. In addition, the method embodiments may include additional steps and / or omit the steps shown. The scope of the present disclosure is not limited in this respect. Unless otherwise specifically stated, the relative arrangement, numerical expressions and numerical values ​​of the parts and steps set forth in these embodiments should be interpreted as being merely exemplary and do not limit the scope of the present disclosure.

[0027] As used in this disclosure, the term "include" and its variations are intended to be open-ended terms that include at least the following elements / features but do not exclude other elements / features, i.e., "including but not limited to." Furthermore, the term "comprise" and its variations are intended to be open-ended terms that include at least the following elements / features but do not exclude other elements / features, i.e., "including but not limited to." Therefore, "include" and "include" are synonymous. The term "based on" means "based, at least in part, on."

[0028] Reference throughout this specification to "one embodiment," "some embodiments," or "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. For example, the term "one embodiment" means "at least one embodiment," the term "another embodiment" means "at least one additional embodiment," and the term "some embodiments" means "at least some embodiments." Furthermore, the appearances of the phrases "in one embodiment," "in some embodiments," or "in an embodiment" in various places throughout this specification are not necessarily all referring to the same embodiment, but may.

[0029] It should be noted that the concepts of "first" and "second" mentioned in this disclosure are only used to distinguish different devices, modules, or units, and are not used to limit the order or interdependence of the functions performed by these devices, modules, or units. Unless otherwise specified, concepts such as "first" and "second" are not intended to imply that the objects described in such a manner must be in a given order in time, space, ranking, or any other manner.

[0030] It should be noted that the modifications of "one" and "multiple" mentioned in the present disclosure are illustrative rather than restrictive, and those skilled in the art should understand that unless otherwise clearly indicated in the context, they should be understood as "one or more".

[0031] The names of the messages or information exchanged between multiple devices in the embodiments of the present disclosure are only used for illustrative purposes and are not used to limit the scope of these messages or information.

[0032] The following detailed description of the embodiments of the present disclosure is provided in conjunction with the accompanying drawings, but the present disclosure is not limited to these specific embodiments. The following specific embodiments may be combined with each other, and the same or similar concepts or processes may not be described in detail in some embodiments. In addition, in one or more embodiments, specific features, structures, or characteristics may be combined in any suitable manner that will be apparent to those skilled in the art from this disclosure.

[0033] It should be understood that the present disclosure does not limit how the image to be applied / processed is obtained. In one embodiment of the present disclosure, the image can be obtained from a storage device, such as an internal memory or an external storage device. In another embodiment of the present disclosure, the image can be captured by mobilizing a camera assembly. It should be noted that the image obtained can be a captured image or a frame of a captured video, and is not particularly limited to this.

[0034] In the context of this disclosure, an image may refer to any of a variety of images, such as a color image, a grayscale image, and the like. It should be noted that, in the context of this specification, the type of image is not specifically limited. Furthermore, the image may be any suitable image, such as a raw image obtained by a camera, or an image that has undergone specific processing, such as preliminary filtering, anti-aliasing, color adjustment, contrast adjustment, normalization, and the like. It should be noted that preprocessing operations may also include other types of preprocessing operations known in the art, which will not be described in detail here.

[0035] In related technologies, when the front-end interface of the source code is relatively complex and there is a big gap between the user's interface requirements, the workload of the user to modify the source code will be very large, resulting in low interface development efficiency; when the upgrade of the source code involves the front-end interface, the interface code adjusted by the user will conflict with the upgraded code, and the maintenance cost is high; the method of directly modifying the source code makes the user face huge challenges in the docking and reuse between the source code and the user-developed code when using his own technology stack to develop the front-end interface, resulting in low development efficiency.

[0036] The present disclosure provides a technical solution that can improve the efficiency of secondary development of interfaces and reduce maintenance costs.

[0037] FIG1 shows a flowchart of an information processing method for interface construction according to some embodiments of the present disclosure.

[0038] As shown in Figure 1, the information processing method for interface construction includes: step S110, receiving a first instruction from a target interface module developed by a user, the first instruction being used to obtain target information related to constructing the target interface; step S120, converting the first instruction into a second instruction supported by the target source code; step S130, obtaining target information from the target source code according to the second instruction; and step S140, sending the obtained target information to the target interface module so that the target interface module constructs the target interface according to the target information. In some embodiments, the information processing method is executed by an information processing device for interface construction. For example, the user is a developer of the target interface, and the target interface module can be a web front-end interface module or a client front-end interface module.

[0039] In the above embodiment, the first instruction in the target interface module developed by the user can be converted and translated into the second instruction supported by the target source code, and then the target information related to the construction of the target interface can be obtained from the target source code according to the second instruction. Since the present disclosure can convert and translate instructions, the user can develop the target interface module based on the target source code based on any programming language, thereby realizing efficient secondary development of the front-end interface of the target source code and improving the efficiency of interface secondary development. In addition, the target interface module constructs the target interface by obtaining information related to the construction of the target interface from the target source code, so that the user can realize fully customized interface customization, consume the front-end service of the target source code on demand, realize free tailoring of the front-end interface of the target source code, and freely combine the interface and layout of the integrated development environment (IDE) based on the underlying capabilities of the target source code, thereby improving the reuse rate of the target source code, reducing the coupling between the target interface and the target source code, and reducing maintenance costs.

[0040] The information processing method for interface construction in some embodiments of the present disclosure will be described in detail below.

[0041] In step S110, a first instruction is received from a target interface module developed by a user, the first instruction being used to obtain target information related to constructing the target interface. The first instruction can be an instruction based on any programming language. For example, the target interface is a file tree display interface.

[0042] In some embodiments, taking the example of an information processing method executed by an intermediate layer, the first instruction obtains the target information by calling at least one interface of the intermediate layer. That is, the intermediate layer will open the interface for users to call. For example, the information processing method can be executed by the intermediate layer of an SDK (Software Development Kit). In addition to the SDK format, the intermediate layer can also be packaged in other formats to provide developers with programming use.

[0043] In some embodiments, the target information includes information related to at least one of a state object, a service object, and a tool object in the target source code. For example, a state object may describe the interface readiness state in the target source code and may be a workspace creation method or function. For example, a service object may be an object of the underlying service set of the target source code. For example, a tool object may be other auxiliary tool objects in the target source code in addition to the state object and the service object. These tool objects include but are not limited to methods, class definitions, etc.

[0044] In step S120, the first instruction is converted into a second instruction supported by the target source code. In some embodiments, the first instruction includes a first object call instruction, and converting the first instruction into the second instruction supported by the target source code includes the following steps.

[0045] First, parse the first instruction.

[0046] Then, according to the parsing result, the first object calling instruction is converted into a second object calling instruction that can be recognized by the target source code.

[0047] Finally, a second instruction including a second object calling instruction is generated.

[0048] In step S130, target information is obtained from the target source code according to the second instruction. In some embodiments, taking the information processing method executed by the middle layer as an example, step S130 can be implemented as follows.

[0049] First, a second instruction is sent to the collector object layer.

[0050] Then, the collector object layer interacts with the target source code to obtain the target information.

[0051] In some embodiments, the intermediate layer, collector object layer and target source code can be packaged in the SDK to provide them to users for programming. For example, the collector object layer defines a collector object, which can be passed into the method of the target source code that is responsible for loading the front-end interface of the target source code as a new formal parameter of the method, so that the collector object can be used as a channel for internal and external communication of the target source code. In the target source code, the collector object is also injected with necessary information such as instances, methods, classes, etc. of the front-end of the target source code. This information includes, for example, status objects, service objects, and tool class objects. The collector object is, for example, a collector object.

[0052] In some embodiments, interacting with the target source code according to the second instruction via the collector object layer to obtain the target information includes: utilizing the collector object layer to execute an object call associated with the second instruction in the target source code to obtain the target information. For example, using an SDK as an example, after the SDK is embedded in the front-end, the collector object can be passed as an actual parameter during initialization. Once the SDK is ready to load, the target information associated with the service object and / or tool object in the target source code can be obtained via the collector object.

[0053] In the above embodiment, the middle layer interacts directly with the target interface module developed by the user, realizes the encapsulation of the underlying logic of the interaction between the collector object layer and the target source code, simplifies the dependencies between modules or classes under development, simplifies the user's development process, and further improves the code maintainability of the user's target interface module.

[0054] In some embodiments, the middle layer sends a second instruction to the collector object layer; the collector object layer interacts with the target source code according to the second instruction to obtain target information; the collector object layer sends the target information to the middle layer; the middle layer receives the target information from the collector object layer.

[0055] In step S140 , the acquired target information is sent to the target interface module so that the target interface module constructs a target interface according to the target information.

[0056] In some embodiments, the target information obtained from the target source code is target information supported by the target source code, and sending the obtained target information to the target interface module includes: in response to the target information supported by the target source code satisfying a conversion condition, converting the target information supported by the target source code into target information supported by the target interface module; and sending the target information supported by the target interface module to the target interface module. For example, if the target source code describes the target information in a non-string format, and the target interface module only supports target information in a string format, the middle layer converts the non-string target information into the string format.

[0057] The interface construction method in some embodiments of the present disclosure will be described below with reference to FIG. 2 .

[0058] FIG2 shows a flowchart of an interface construction method according to some embodiments of the present disclosure.

[0059] As shown in Figure 2, the interface construction method includes: step S210, sending a first instruction based on any programming language to the middle layer, the first instruction is used to obtain target information related to constructing the target interface from the target source code; step S220, receiving target information recognizable by the programming language of the first instruction from the middle layer; and step S230, using the target information recognizable by the programming language of the first instruction to construct the target interface. The interface construction method is executed by a target interface module developed by the user. In the case where the user can develop a target interface module based on any programming language, the middle layer can convert the first instruction so that the target source code can be recognized, and return the target information recognizable by the programming language corresponding to the first instruction to the target interface module, thereby improving the reuse rate of the target source code, reducing the coupling between the target interface and the target source code, and reducing maintenance costs. Developing a target interface module based on the target source code can improve the efficiency of secondary development of the interface.

[0060] In some embodiments, constructing a target interface using the target information includes displaying the target information in the target interface according to an interface display instruction in the target interface module.

[0061] In the above embodiment, the target interface module developed by the user can send a first instruction based on any programming language to obtain target information related to building the target interface in the target source code, thereby improving the code maintainability of the target interface module, reducing maintenance costs, and improving development efficiency.

[0062] The following will take SDK as an example and describe in detail the interaction process between the target interface module and SDK in some embodiments of the present disclosure in conjunction with FIG3 .

[0063] FIG3 shows a schematic diagram of the interaction between the target interface module and the SDK according to some embodiments of the present disclosure.

[0064] As shown in Figure 3, the target interface module 30 is developed by the user based on any programming language. In some embodiments, there can be multiple target interface modules 30, and different target interface modules display different parts of the entire front-end interface, and each part serves as a target interface.

[0065] The target interface module 30 sends a first instruction for acquiring target information related to constructing a target interface to the middle layer 31 of the SDK.

[0066] The middle layer 31 receives a first instruction from the target interface module developed by the user. The first instruction is used to obtain target information related to constructing the target interface. The first instruction can be based on any programming language. In some embodiments, for example, the information processing method is executed by the middle layer of the SDK. The first instruction obtains the target information by calling at least one interface of the middle layer. In other words, the middle layer opens the interface for users to call.

[0067] In some embodiments, the target information includes information related to at least one of a state object 331, a service object 332, and a tool class object 333 in the target source code 33. For example, the state object 331 can describe the interface readiness state in the target source code and can be a workspace creation method or function. For example, the service object 332 can be an object of the underlying service set of the target source code. For example, the tool class object 333 can be other auxiliary tool class objects in the target source code in addition to the state object and service object. These tool class objects include but are not limited to methods, class definitions, etc.

[0068] The middle layer 31 converts the first instruction into a second instruction supported by the target source code. In some embodiments, the first instruction includes a first object call instruction, and converting the first instruction into the second instruction supported by the target source code includes the following steps.

[0069] First, parse the first instruction.

[0070] Then, according to the parsing result, the first object calling instruction is converted into a second object calling instruction that can be recognized by the target source code.

[0071] Finally, a second instruction including a second object calling instruction is generated.

[0072] The middle layer 31 also obtains target information from the target source code according to the second instruction. In some embodiments, taking the information processing method executed by the middle layer of the SDK as an example, obtaining target information from the target source code according to the second instruction can be achieved in the following manner.

[0073] First, the second instruction is sent to the collector object layer 32 of the SDK.

[0074] Then, the target information is obtained by interacting with the target source code 33 through the collector object layer 32. The SDK packages the intermediate layer 31, the collector object layer 32, and the target source code 33. In some embodiments, the collector object layer 32 interacts with the target source code 33 according to the second instruction to obtain the target information, including: using the collector object layer 32 to execute an object call related to the second instruction in the target source code 33 to obtain the target information.

[0075] In the above embodiment, the SDK's middle layer interacts directly with the target interface module developed by the user, realizing the encapsulation of the underlying logic of the interaction between the SDK's collector object layer and the target source code, simplifying the dependencies between modules or classes under development, simplifying the user's development process, and further improving the code maintainability of the user's target interface module.

[0076] In some embodiments, the middle layer 31 sends a second instruction to the collector object layer 32; the collector object layer 32 interacts with the target source code 33 according to the second instruction to obtain target information; the collector object layer 32 sends the target information to the middle layer 31; the middle layer 31 receives the target information from the collector object layer 32.

[0077] The middle layer 31 also sends the acquired target information to the target interface module 30 so that the target interface module 30 constructs a target interface according to the target information.

[0078] In some embodiments, the target information obtained from the target source code 33 is target information supported by the target source code, and the middle layer 31 sending the obtained target information to the target interface module 30 includes: in response to the target information supported by the target source code satisfying a conversion condition, converting the target information supported by the target source code into target information supported by the target interface module 30; and sending the target information supported by the target interface module 30 to the target interface module 30. For example, if the target source code describes the target information in a non-string format, and the target interface module only supports target information in a string format, the middle layer converts the target information in the non-string format into target information in a string format.

[0079] In some embodiments, the target interface module 30 receives target information from the middle layer 31 and constructs a target interface using the target information.

[0080] The embodiment of FIG3 is merely an example and does not constitute a specific limitation on the present disclosure. For example, the middle layer may not be packaged in the SDK, but may be provided to users in other forms for programming.

[0081] FIG4 shows a block diagram of an information processing device for interface construction according to some embodiments of the present disclosure.

[0082] As shown in FIG. 4 , the information processing device 4 for interface construction includes a receiving module 411 , a converting module 412 , an acquiring module 413 and a sending module 414 .

[0083] The receiving module 411 is configured to receive a first instruction from a target interface module developed by a user, where the first instruction is used to obtain target information related to constructing the target interface, for example, executing step S110 as shown in FIG1 . In some embodiments, the receiving module 411 is further configured to execute other embodiments of step S110 as shown in FIG1 .

[0084] The conversion module 412 is configured to convert the first instruction into a second instruction supported by the target source code, for example, executing step S120 as shown in FIG1 . In some embodiments, the conversion module 412 is further configured to execute other embodiments of step S120 as shown in FIG1 .

[0085] The acquisition module 413 is configured to acquire target information from the target source code according to the second instruction, for example, executing step S130 as shown in FIG1 . In some embodiments, the acquisition module 413 is further configured to execute other embodiments of step S130 as shown in FIG1 .

[0086] The sending module 414 is configured to send the acquired target information to the target interface module so that the target interface module constructs a target interface according to the target information, for example, executing step S140 as shown in Figure 1. In some embodiments, the sending module 414 is further configured to execute other embodiments of step S140 as shown in Figure 1.

[0087] In some embodiments, an intermediate layer is deployed in information processing device 4, including receiving module 411, conversion module 412, acquisition module 413, and sending module 414. Acquisition module 411 in the intermediate layer is further configured to: send a second instruction to the collector object layer; interact with the target source code through the collector object layer to obtain the target information. In some embodiments, the implementation of the intermediate layer and the collector object layer can refer to the aforementioned embodiments and will not be repeated here. For example, the intermediate layer is packaged in an SDK, and the SDK is installed in information processing device 4.

[0088] FIG5 is a block diagram illustrating an interface construction device according to some embodiments of the present disclosure.

[0089] As shown in FIG5 , the interface building device 5 includes a target interface module 50 developed by a user.

[0090] The target interface module 50 is configured to send a first instruction based on any programming language to the middle layer, where the first instruction is used to obtain target information related to constructing the target interface from the target source code; receive target information recognizable by the programming language of the first instruction from the middle layer; and construct the target interface using the target information recognizable by the programming language of the first instruction, for example, executing steps S210 to S230 as shown in Figure 2.

[0091] FIG6 illustrates a block diagram of an electronic device according to some embodiments of the present disclosure.

[0092] As shown in Figure 6, the electronic device 6 includes: a memory 61; and a processor 62 coupled to the memory 61, and the processor 62 is configured to execute the information processing method or interface construction method for interface construction described in any of the aforementioned embodiments based on instructions stored in the memory 61.

[0093] Memory 61 is used to store one or more computer-readable instructions. Memory 61 may include any combination of various forms of computer-readable storage media, such as volatile memory and / or non-volatile memory, including but not limited to random access memory (RAM), dynamic random access memory (DRAM), static random access memory (SRAM), read-only memory (ROM), and flash memory. Memory 61 may, for example, store an operating system, application programs, a boot loader, a database, and other programs, as well as various application programs and data.

[0094] The processor 62 is configured to execute computer-readable instructions to implement the information processing method or interface construction method described in any of the aforementioned embodiments. The specific implementation of each step of the information processing method or interface construction method can be found in the aforementioned embodiments, and any repetitions are omitted here.

[0095] The processor 62 and the memory 61 can communicate with each other directly or indirectly. For example, the processor 62 and the memory 61 can communicate via a network. The network can include a wireless network, a wired network, and / or any combination of wireless and wired networks. The processor 62 and the memory 61 can also communicate with each other via a system bus, which is not limited in this disclosure.

[0096] It should be noted that the components of the electronic device 6 shown in FIG6 are merely exemplary and non-limiting. The electronic device 6 may also have other components according to actual application requirements. The processor 62 may control other components in the electronic device 6 to perform desired functions.

[0097] The electronic device may be implemented by software, firmware and / or hardware, and may be integrated into an electronic device installed with relevant application programs.

[0098] FIG7 shows a block diagram of an electronic device according to some further embodiments of the present disclosure.

[0099] The electronic device 7 shown in FIG. 7 may be a computer system with a dedicated hardware structure, which can execute corresponding functions when a relevant application program is installed.

[0100] Electronic devices include, but are not limited to, mobile terminals such as smart phones, laptops, personal digital assistants (PDAs), tablet personal computers (Tablet PCs), PMPs (portable multimedia players), vehicle-mounted terminals (such as vehicle-mounted navigation terminals), wearable devices, etc., as well as fixed terminals such as digital televisions, desktop computers, etc.

[0101] As shown in Figure 7, the central processing unit (CPU) 71 performs various processes according to the program stored in the read-only memory (ROM) 72 or the program loaded from the storage part 78 to the random access memory (RAM) 73. In the RAM 73, the data required when the CPU 71 performs various processes, etc. are stored as needed. The central processing unit is merely exemplary and may also be other types of processors, such as the various processors described above. The ROM 72, RAM 73 and storage part 78 may be various forms of computer-readable storage media. It should be noted that although the ROM 72, RAM 73 and storage part 78 are shown separately in Figure 7, one or more of them may be combined or located in the same or different memory or storage modules.

[0102] The CPU 71, the ROM 72, and the RAM 73 are connected to one another via a bus 74. To the bus 74, an input / output interface 75 is also connected.

[0103] The following components are connected to the input / output interface 75: an input portion 76, such as a touch screen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; an output portion 77, including a display, such as a cathode ray tube (CRT), liquid crystal display (LCD), speaker, vibrator, etc.; a storage portion 78, including a hard disk, magnetic tape, etc.; and a communication portion 79, including a network interface card, such as a LAN card, modem, etc. The communication portion 79 allows communication processing to be performed via a network, such as the Internet. It will be readily understood that although FIG7 shows that the various devices or modules in the electronic device 7 communicate via bus 74, they may also communicate via a network or other means, wherein the network may include a wireless network, a wired network, and / or any combination of wireless and wired networks.

[0104] A drive 710 is also connected to the input / output interface 75 as needed. A removable medium 711 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc. is mounted on the drive 710 as needed so that a computer program read therefrom is installed in the storage section 78 as needed.

[0105] When the series of processing described above is implemented by software, the program constituting the software can be installed from a network such as the Internet or a storage medium such as the removable medium 711 .

[0106] According to an embodiment of the present disclosure, the process described above with reference to the flowchart can be implemented as a computer software program. For example, some embodiments of the present disclosure include a computer program product, which, when running on a computer, enables the computer to implement the information processing method for interface construction or the interface construction method described in any of the aforementioned embodiments. The computer program product includes a computer program carried on a computer-readable medium, the computer program containing program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from the network through the communication part 79, or installed from the storage part 78, or installed from the ROM 72. When the computer program is executed by the CPU 71, the information processing method for interface construction or the interface construction method of the embodiment of the present disclosure is executed.

[0107] It should be noted that, in the context of the present disclosure, a computer-readable medium may be a tangible medium that may contain or store a program for use by an instruction execution system, apparatus, or device or for use in conjunction with an instruction execution system, apparatus, or device.

[0108] The computer readable medium may be a computer readable storage medium, or a computer readable signal medium, or any combination of the two.

[0109] Computer-readable storage media include, but are not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices or components, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, an electrical connection having one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, device or device. A computer program is stored on a computer-readable storage medium that, when executed by a processor, implements the information processing method for interface construction or the interface construction method described in any of the aforementioned embodiments.

[0110] A computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, which carries a computer-readable program code. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which may send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination thereof.

[0111] The computer-readable medium may be included in the electronic device, or may exist independently without being incorporated into the electronic device.

[0112] In some embodiments, a computer program is further provided, comprising: instructions, which, when executed by a processor, cause the processor to execute the information processing method for interface construction or the interface construction method of any of the above embodiments. For example, the instructions may be embodied as computer program code.

[0113] In embodiments of the present disclosure, computer program code for performing the operations of the present disclosure can be written in one or more programming languages ​​or combinations thereof, including but not limited to object-oriented programming languages, such as Java, Smalltalk, C++, and conventional procedural programming languages, such as "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as an independent software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In situations involving a remote computer, the remote computer can be connected to the user's computer via any type of network (including a local area network (LAN) or a wide area network (WAN)), or can be connected to an external computer (e.g., using an Internet service provider to connect via the Internet).

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

[0115] The functions described above may be performed at least in part by one or more hardware logic components. For example, and without limitation, exemplary hardware logic components that may be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on chips (SOCs), complex programmable logic devices (CPLDs), and the like.

[0116] Although some specific embodiments of the present disclosure have been described in detail by way of examples, those skilled in the art will appreciate that the above examples are for illustrative purposes only and are not intended to limit the scope of the present disclosure. Those skilled in the art will appreciate that modifications may be made to the above embodiments without departing from the scope and spirit of the present disclosure. The scope of the present disclosure is defined by the appended claims.

Claims

1. An information processing method for interface construction, comprising: Receiving a first instruction from a target interface module developed by a user, wherein the first instruction is used to obtain target information related to constructing the target interface; Converting the first instruction into a second instruction supported by the target source code; According to the second instruction, obtaining the target information from the target source code; The acquired target information is sent to the target interface module so that the target interface module constructs the target interface according to the target information.

2. The information processing method according to claim 1, wherein: The information processing method is executed by the middle layer, and according to the second instruction, obtaining the target information from the target source code includes: sending the second instruction to the collector object layer; The target information is acquired by interacting with the target source code through the collector object layer.

3. The information processing method according to claim 2, wherein: Acquiring the target information by interacting with the target source code through the collector object layer includes: The collector object layer is used to execute an object call related to the second instruction in the target source code to obtain the target information.

4. The information processing method according to claim 2 or 3, wherein: The first instruction obtains the target information by calling at least one interface of the intermediate layer.

5. The information processing method according to any one of claims 1 to 4, wherein: The first instruction includes a first object call instruction, and converting the first instruction into a second instruction supported by the target source code includes: parsing the first instruction; According to the parsing result, converting the first object call instruction into a second object call instruction recognizable by the target source code; The second instruction including the second object call instruction is generated.

6. The information processing method according to any one of claims 1 to 4, wherein: The target information obtained from the target source code is target information supported by the target source code, and sending the obtained target information to the target interface module includes: In response to the target information supported by the target source code meeting a conversion condition, converting the target information supported by the target source code into target information supported by the target interface module; Sending target information supported by the target interface module to the target interface module.

7. The information processing method according to any one of claims 1 to 4, wherein: The target information includes information related to at least one of a state object, a service object, and a tool object in the target source code.

8. An interface construction method, executed by a target interface module developed by a user, comprising: Sending a first instruction based on any programming language to the middle layer, wherein the first instruction is used to obtain target information related to building a target interface from the target source code; receiving the target information recognizable by the arbitrary programming language from the intermediate layer; The target interface is constructed using the target information that can be identified by the arbitrary programming language.

9. An information processing device for interface construction, comprising: A receiving module configured to receive a first instruction from a target interface module developed by a user, wherein the first instruction is used to obtain target information related to constructing the target interface; a conversion module, configured to convert the first instruction into a second instruction supported by the target source code; an acquisition module, configured to acquire the target information from the target source code according to the second instruction; The sending module is configured to send the acquired target information to the target interface module, so that the target interface module constructs the target interface according to the target information.

10. The information processing apparatus according to claim 9, wherein: The information processing device is deployed with an intermediate layer, the receiving module, the conversion module, the acquisition module and the sending module are included in the intermediate layer, and the acquisition module of the intermediate layer is further configured to: sending the second instruction to the collector object layer; The target information is acquired by interacting with the target source code through the collector object layer.

11. An interface construction device, comprising a target interface module developed by a user, configured to: Sending a first instruction based on any programming language to the middle layer, wherein the first instruction is used to obtain target information related to building a target interface from the target source code; receiving the target information recognizable by the arbitrary programming language from the intermediate layer; The target interface is constructed using the target information that can be identified by the arbitrary programming language.

12. An electronic device comprising: Memory; as well as A processor coupled to the memory, the processor being configured to execute the information processing method according to any one of claims 1 to 7 or the interface building method according to claim 8 based on instructions stored in the memory.

13. A computer-readable storage medium having a computer program stored thereon, wherein when the program is executed by a processor, the information processing method according to any one of claims 1 to 7 or the interface construction method according to claim 8 is implemented.

14. A computer program product, which, when executed on a computer, enables the computer to implement the information processing method according to any one of claims 1 to 7 or the interface building method according to claim 8.

15. A computer program comprising: An instruction, when executed by a processor, causes the processor to execute the information processing method according to any one of claims 1 to 7 or the interface construction method according to claim 8.

Images