CN106547519B - Information processing method and system - Google Patents
Information processing method and system Download PDFInfo
- Publication number
- CN106547519B CN106547519B CN201510589975.7A CN201510589975A CN106547519B CN 106547519 B CN106547519 B CN 106547519B CN 201510589975 A CN201510589975 A CN 201510589975A CN 106547519 B CN106547519 B CN 106547519B
- Authority
- CN
- China
- Prior art keywords
- file
- resource
- unit
- identifier
- project
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Landscapes
- Stored Programmes (AREA)
Abstract
The embodiment of the invention discloses an information processing method and a system, wherein the method comprises the following steps: creating class library engineering; wherein the class library engineering comprises source code and resources required by the execution of the source code; establishing a first file and a second file in the class library engineering; declaring an identity of the resource in the first file; defining an identity of the resource in the second file; wherein the declaration of the first file and the definition in the second file are for a reference to a customer application project.
Description
Technical Field
The present invention relates to the field of information technologies, and in particular, to an information processing method and system.
Background
In the development process of application software (such as android software), a class library is often required to be developed by the application software, and the class library is packaged into a jar package for being called by others. When the application software is released, pure codes are packaged into src.jar, meanwhile, an agent project of an intermediate agent is used, the packaged src.jar is added into the reference of the agent project, used resources are placed into the agent project, and the agent project is directly released to a client.
When the client application needs to be used, the reference to the proxy engineering is simply added. Jar contains the R.java file generated by compiling the resource. Jar the use of resources in src.jar can be determined by looking up the r.java file. When the customer project is recompiled, the resources in the proxy project are processed, another R.java is generated, and a new definition of the resources is generated in the regenerated R.java. This may have a problem that the definition of the r.java file in src.jar and the definition of the r.java in the customer project are not consistent. This may result in an error that the resource cannot be found. In the existing solution, a Map tool class needs to be added, and the resources are mapped and searched through the names of the resources.
But there are problems in that: when the codes are modified, all the r.xxx.ids in the r.java may need to be called and replaced by the call of the Map tool type function, and in this time, the worker needs to modify the codes one by one manually, which is tedious and prone to errors, and also needs to provide an additional Map tool to implement the above operations.
Disclosure of Invention
Accordingly, embodiments of the present invention are directed to an information processing method and system that at least partially solves one or more of the problems set forth above.
In order to achieve the purpose, the technical scheme of the invention is realized as follows:
a first aspect of an embodiment of the present invention provides an information processing method, where the method includes:
creating class library engineering; wherein the class library engineering comprises source code and resources required by the execution of the source code;
establishing a first file and a second file in the class library engineering;
declaring an identity of the resource in the first file;
defining an identity of the resource in the second file;
wherein the declaration of the first file and the definition in the second file are for a reference to a customer application project.
Based on the above scheme, the method further comprises:
compiling the source code for the first time to generate a third file comprising the identification and the definition of the resource;
the declaring, in the first file, an identification of the resource includes:
selecting an identifier of a resource needing to be disclosed from the third file, and adding the identifier to the first file;
said defining an identity of said resource in said second file comprising:
and selecting the identifier of the resource needing to be disclosed from the third file, and adding the identifier to the second file.
Based on the above scheme, the method further comprises:
compiling the class library engineering for the second time based on the first file and the second file to form a compiled code;
forming a resource catalog based on the required resources;
and packaging the compiled code and the resource directory to form a code packet.
Based on the above scheme, the method further comprises:
creating a proxy project;
adding the first file, the second file and the resource in an agent library of the agent project;
adding a reference to the code package in the proxy engineering.
Based on the above scheme, the method further comprises:
creating a client application project;
the proxy library is referenced in the client application project.
A second aspect of an embodiment of the present invention provides an information processing system, including:
the first creating unit is used for creating class library engineering; wherein the class library engineering comprises source code and resources required by the execution of the source code;
the establishing unit is used for establishing a first file and a second file in the class library engineering;
a declaration unit, configured to declare an identifier of the resource in the first file;
a definition unit, configured to define, in the second file, an identifier of the resource;
wherein the declaration of the first file and the definition in the second file are for a reference to a customer application project.
Based on the above scheme, the system further comprises:
the first compiling unit is used for compiling the source code for the first time and generating a third file comprising the identification and the definition of the resource;
the declaration unit is specifically configured to select an identifier of a resource to be disclosed from the third file, and add the identifier to the first file;
the definition unit is specifically configured to select an identifier of a resource that needs to be disclosed from the third file, and add the identifier to the second file.
Based on the above scheme, the system further comprises:
the second compiling unit is used for compiling the class library engineering for the second time based on the first file and the second file to form a compiled code;
a first forming unit, configured to form a resource directory based on the required resource;
and the second forming unit is used for packaging the compiled codes and the resource directory to form a code package.
Based on the above scheme, the system further comprises:
the second establishing unit is used for establishing a proxy project;
an adding unit, configured to add the first file, the second file, and the resource in an agent library of the agent project;
and the first reference unit is used for adding a reference to the code package in the proxy engineering.
Based on the above scheme, the system further comprises:
a third creating unit for creating a client application project;
and the second reference unit is used for referencing the proxy library in the client application project.
According to the information processing method and the information processing system provided by the embodiment of the invention, a first file and a second file are established in a class library project; the first file is used for declaring resources required by execution of the source code, and the second file defines the resources declared in the first file, so that subsequent client application projects can directly follow the declarations and definitions in the two files without additionally declaring and defining, and the phenomenon that the declarations and definitions of the same resource are not uniform due to the fact that the declarations and definitions are respectively declared and defined in different projects is avoided; and a mapping relation is not required to be additionally established, so that when codes are modified subsequently and the identification and the name of the related resource are replaced, manual searching is not required one by one for replacement, the operation of workers is greatly reduced, and the intelligence and the efficiency are improved.
Drawings
Fig. 1 is a schematic flowchart of a first information processing method according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating a second information processing method according to an embodiment of the present invention;
FIG. 3 is a flowchart illustrating a third information processing method according to an embodiment of the present invention;
FIG. 4 is a block diagram of a first information processing system according to an embodiment of the present invention;
FIG. 5 is a block diagram of a second information handling system according to an embodiment of the present invention;
fig. 6 is a flowchart illustrating a fourth information processing method according to an embodiment of the present invention.
Detailed Description
The technical solution of the present invention is further described in detail with reference to the drawings and the specific embodiments of the specification.
The method comprises the following steps:
as shown in fig. 1, the present embodiment provides an information processing method, including:
step S110: creating class library engineering; wherein the class library engineering comprises source code and resources required by the execution of the source code;
step S120: establishing a first file and a second file in the class library engineering;
step S130: declaring an identity of the resource in the first file;
step S140: defining an identity of the resource in the second file;
wherein the declaration of the first file and the definition in the second file are for a reference to a customer application project.
The information processing method described in this embodiment can be applied to the compiling of codes and the software development process. The English corresponding to the Class library Project is a Class Project, which is a process for forming a set comprising a plurality of Class objects.
The class library engineering includes source code written using various programming languages, for example, source code written using Java. The required resources can comprise various materials required by the execution of source codes such as pictures, storage spaces, characters, links and the like.
A first file and a second file will be created in step S120. The first file may be ids. xml; xml may be public. An identification of the resource is declared in a first file. The resource may be a part of the resources required for execution of the source code that needs to be exposed. The identifier of the resource may be a variable corresponding to the identifier information of the resource. The second file defines the identifier of the resource, which is equivalent to assigning the variable, where the assignment may specifically be a label of the resource, a name of the resource, or a uniform resource address of the resource, such as a number of a picture. Typically the definition in the second file is a definition of the identity claimed in the first file.
In this embodiment, after the first file is declared and the second file is defined, when the client application project is subsequently processed, a developer of the client application project does not need to declare and define the identifier of the resource again, so that the declaration and definition formed in the client application project is not generated, and the problem different from the declaration and definition formed in the class library project is not generated, so that the unification of the declaration and definition of the identifier of the resource in the class library project and the client application project is realized, and a mapping directory and the like do not need to be established through Map. When the subsequent code is rewritten, the rewriting personnel do not need to check and rewrite one by one, so that the working efficiency is improved, and errors caused by manual factors are avoided.
As shown in fig. 2, the method further comprises:
step S101: compiling the source code for the first time to generate a third file comprising the identification and the definition of the resource;
the step S130 may include: selecting an identifier of a resource needing to be disclosed from the third file, and adding the identifier to the first file;
the step S140 includes: and selecting the identifier of the resource needing to be disclosed from the third file, and adding the identifier to the second file.
For example, taking the compilation of class library engineering of Java programs as an example, the r.java file will be formed after the first compilation of the source code. The file may include a statement and definition of the resource.
To ensure that the references to the subsequent client application projects are correct, in this embodiment, the step S130 copies the identification of the required exposed resources directly from the r.java file to implement the declaration. In step S140, the definition of the required public resource is directly copied from the r.java file to implement the definition of the resource.
Of course, various r.class files will be formed after compilation. It is noted that "R" in both r.java file and r.class can be generically referred to as a file name.
Therefore, the declaration of the identifier of the resource to be disclosed in the first file and the definition of the identifier of the resource to be disclosed in the second file are simply and conveniently realized, and the same declaration and the same definition of the identifier of the same resource in the subsequent client application engineering and the class library engineering can be ensured, so that the conflict can be avoided.
Further, as shown in fig. 3, the method further includes:
step S150: compiling the class library engineering for the second time based on the first file and the second file to form a compiled code;
step S160: forming a resource catalog based on the required resources;
step S170: and packaging the compiled code and the resource directory to form a code packet.
For example, taking Java code as an example, a second compilation is performed on the code after the first compilation, for example, a class file after the first compilation is compiled again, and during this compilation, the identifier and definition that need to be replaced in the code are replaced by the declaration in the first file and the definition in the second file. Obviously, when compiling is carried out at this time, the first file and the second file are searched, and the compiled code after compiling is carried out for the second time, the identifier of the resource can be ensured to be consistent with the identifier of the resource in the first file and the second file, so that the identifier of the resource can be kept consistent with the statement and definition of the identifier of the resource in the client application project conveniently. And the compiled code package can form new src.
Furthermore, the method further comprises:
creating a proxy project;
adding the first file, the second file and the resource in an agent library of the agent project;
adding a reference to the code package in the proxy engineering.
For example, taking android application code development as an example, the proxy engineering is an intermediate engineering located in class library engineering and customer application engineering. In this embodiment, the first file and the second file and the required resource need to be added to the agent library of the agent project. While a reference to the code package needs to be added. By the execution of this step, the proxy project refers to the declaration and definition of the identity of the resource that needs to be exposed. The code package can be invoked by reference to the code package.
Furthermore, the method further comprises:
creating a client application project;
the proxy library is referenced in the client application project.
The agent library which comprises the first file, the second file and the resource and is added with the code package reference can be directly quoted in the client application project, so that when the client application project calls the agent library, the statement of the resource identifier of the first file and the definition in the second file are obtained together, and thus, one is not required to be additionally created again, so that the unification of the statement and the definition of the identifier of the same resource in the library engineering, the agent engineering and the client application project is obviously ensured, the processes of mapping directory establishment and the like are not required, and meanwhile, the manual searching and replacing operation in the code modification process is avoided.
The embodiment of the system is as follows:
as shown in fig. 4, the present embodiment provides an information processing system including:
a first creating unit 110, configured to create a class library project; wherein the class library engineering comprises source code and resources required by the execution of the source code;
an establishing unit 120, configured to establish a first file and a second file in the class library engineering;
a declaring unit 130, configured to declare an identity of the resource in the first file;
a defining unit 140, configured to define the identifier of the resource in the second file;
wherein the declaration of the first file and the definition in the second file are for a reference to a customer application project.
The information processing system described in this embodiment can be used for application development, for example, for android application development.
The hardware structures of the first creating unit 110, the establishing unit 120, the declaring unit 130 and the defining unit 140 may correspond to a processor or a processing circuit. The processor may comprise a central processing unit, microprocessor, digital signal processor, or programmable array. The processing circuit may comprise an application specific integrated circuit. Also included within the system is a storage medium having executable code stored thereon. The processor and the processing circuitry may be connected to the storage medium via a communication interface, such as an internal communication interface bus. The processor or the processing circuit implements the functions of the above units by executing the executable code. Any two units may be integrated with the same processor or processing circuit, or each unit may correspond to a different processor or processing circuit. When two or more units are integrated to correspond to the same processor or processing circuit, the processor or processing circuit may employ time division multiplexing or concurrent threads to process the functions of the different units.
The system of the embodiment can be used for the information processing method described in the method example, and through establishment of the first file and the second file and declaration and definition of the identifier of the resource, subsequent client application projects are facilitated to be free from additional declaration and definition of the identifier, and the conflict problem caused by different declarations and definitions of the same resource due to two or more declarations and definitions of different projects is avoided.
As shown in fig. 5, the system further includes:
a first compiling unit 150, configured to compile the source code for a first time, and generate a third file including an identifier and a definition of the resource;
the declaration unit 130 is specifically configured to select an identifier of a resource to be disclosed from the third file, and add the identifier to the first file;
the defining unit 140 is specifically configured to select an identifier of a resource that needs to be disclosed from the third file, and add the identifier to the second file.
The specific structure of the first compiling unit 150 in the present embodiment may include a processor or a processing circuit, and the specific structure of the processor or the processing circuit may be referred to in the foregoing embodiments. In this embodiment, the first compiling unit 150 compiles the source code for the first time to form a compiled code or file. The third file is a file formed by compiling the source code, for example, an r.java file formed after the first compiling. And storing a statement and a definition of the identification of the resource of the compiled code after compiling in the R.java file. In this embodiment, in order to repeatedly define a resulting definition conflict, in this embodiment, the declaration unit 130 is specifically configured to select an identifier of a resource that needs to be disclosed from a third file. The definition unit 140 is specifically configured to select a definition from a third file.
Further, the system further comprises:
the second compiling unit is used for compiling the class library engineering for the second time based on the first file and the second file to form a compiled code;
a first forming unit, configured to form a resource directory based on the required resource;
and the second forming unit is used for packaging the compiled codes and the resource directory to form a code package.
In this embodiment, the system further includes a second compiling unit, and a physical structure of the second compiling unit is similar to that of the first compiling unit, except that the compiled object is different.
The specific structure of the first forming unit and the second forming unit may also include a processor or processing circuitry. The first forming unit will form the resource directory so that it can know which resources are needed for the code to run by querying the resource directory later when the software or program is used.
The second forming unit will eventually form a code package. Jar may be the code package during Java application development.
Further, the system further comprises:
the second establishing unit is used for establishing a proxy project;
an adding unit, configured to add the first file, the second file, and the resource in an agent library of the agent project;
and the first reference unit is used for adding a reference to the code package in the proxy engineering.
The system of this implementation may also be used to create a proxy project. The specific structure of the second creation unit may be similar to the first creation unit.
The physical structure of both the adding unit and the first referring unit may correspond to a processor or a processing circuit. The agent library is referenced by the addition of the first file and the second file, so that when a subsequent client application project references the agent library, additional declaration and definition of resources are not needed, and conflicts formed by inconsistency caused by declaration and definition of the same resource in different projects can be solved.
Further, the system further comprises:
a third creating unit for creating a client application project;
and the second reference unit is used for referencing the proxy library in the client application project.
The third creating unit described in this embodiment has a similar structure to the first creating unit and the second creating unit, and can participate in the corresponding description of the first creating unit and the second creating unit.
The second referenced elements are similar in physical structure to the first referenced elements and are not repeated here.
In this embodiment, the third creating unit creates the client application project, and the agent library includes the first file and the second file by referring to the agent library, so that the resource does not need to be declared and defined again, the problems of inconsistency and the like caused by declaration and definition of different projects can be avoided, and a large amount of tedious work caused when a subsequent code is rewritten can be facilitated.
Two specific examples are provided below in connection with any of the embodiments described above:
example one:
as shown in fig. 6, the information processing method provided by the present example includes:
step 1: creating and compiling, specifically comprising: creating a class library project and compiling the class library project.
Step 2: adds and modifies ids. xml and public.xml, which correspond to the first file and the second file, respectively.
And step 3: and modifying the layout and other resource files. This corresponds to a second compilation, whereby the resource identification and definition in the resource file is replaced with the declaration of the first file and the definition of the second file.
And 4, step 4: jar is generated by derivation. Jar here is the aforementioned code package.
And 5: and creating, specifically creating a proxy project. Jar, ids, xml, and public, xml are added to the quote, i.e., ids, xml, and public, xml are added to the proxy library.
Step 6: and adding the dependency, wherein adding the dependency means that the client application engineering adds the proxy library into the dependency, so that the proxy library can be called in the client application engineering subsequently.
Example two:
the present example provides an information processing method, the method comprising:
step 11: creating class library engineering, including source code and required resource, and making first conventional compilation.
Step 12: and adding ids.xml and public.xml in class library engineering, adding an id statement in ids.xml according to the R.java file generated by compiling, and adding a corresponding id definition in public.xml. Xml corresponds to the aforementioned first document; xml corresponds to the second file. The id corresponds to the identity of the resource.
Step 13: and recompiling the class library engineering, and exporting the recompiled code and the content form under the resource directory to be src. The resource directory is a directory of resources that need to be used.
Step 14: creating an intermediate proxy project (for example, creating an android library), adding the resources used in the class library project, ids. xml and public. xml into the proxy library project, and adding the reference to src. jar.
Step 15: and adding a reference to the proxy library engineering in the client application engineering.
With the information processing method of the present example, there is no need to modify the code of a Software development tool (SDK) and provide an additional Map tool class, which greatly reduces the workload of SDK development. The prior art uses name mapping, so that the original calls of R.xxx.id are all converted into function calls, and the proposal keeps using the calls of R.xxx.id declared in the first file, so that compared with the prior art, the program operation efficiency is greatly improved.
In the several embodiments provided in the present application, it should be understood that the disclosed apparatus and method may be implemented in other ways. The above-described device embodiments are merely illustrative, for example, the division of the unit is only a logical functional division, and there may be other division ways in actual implementation, such as: multiple units or components may be combined, or may be integrated into another system, or some features may be omitted, or not implemented. In addition, the coupling, direct coupling or communication connection between the components shown or discussed may be through some interfaces, and the indirect coupling or communication connection between the devices or units may be electrical, mechanical or other forms.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, that is, may be located in one place, or may be distributed on a plurality of network units; some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, all the functional units in the embodiments of the present invention may be integrated into one processing module, or each unit may be separately used as one unit, or two or more units may be integrated into one unit; the integrated unit can be realized in a form of hardware, or in a form of hardware plus a software functional unit.
Those of ordinary skill in the art will understand that: all or part of the steps for implementing the method embodiments may be implemented by hardware related to program instructions, and the program may be stored in a computer readable storage medium, and when executed, the program performs the steps including the method embodiments; and the aforementioned storage medium includes: a mobile storage device, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and other various media capable of storing program codes.
The above description is only for the specific embodiments of the present invention, but the scope of the present invention is not limited thereto, and any person skilled in the art can easily conceive of the changes or substitutions within the technical scope of the present invention, and all the changes or substitutions should be covered within the scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the appended claims.
Claims (10)
1. An information processing method, characterized in that the method comprises:
creating class library engineering; wherein the class library engineering comprises source code and resources required by the execution of the source code;
establishing a first file and a second file in the class library engineering;
declaring an identity of the resource in the first file;
defining an identity of the resource in the second file;
wherein the declaration of the first file and the definition in the second file are for a reference to a customer application project.
2. The method of claim 1,
the method further comprises the following steps:
compiling the source code for the first time to generate a third file comprising the identification and the definition of the resource;
the declaring, in the first file, an identification of the resource includes:
selecting an identifier of a resource needing to be disclosed from the third file, and adding the identifier to the first file;
said defining an identity of said resource in said second file comprising:
and selecting the identifier of the resource needing to be disclosed from the third file, and adding the identifier to the second file.
3. The method according to claim 1 or 2,
the method further comprises the following steps:
compiling the source code for the second time based on the first file and the second file to form a compiled code;
forming a resource catalog based on the required resources;
and packaging the compiled code and the resource directory to form a code packet.
4. The method of claim 3,
the method further comprises the following steps:
creating a proxy project;
adding the first file, the second file and the resource in an agent library of the agent project;
adding a reference to the code package in the proxy engineering.
5. The method of claim 4,
the method further comprises the following steps:
creating a client application project;
the proxy library is referenced in the client application project.
6. An information processing system, the system comprising:
the first creating unit is used for creating class library engineering; wherein the class library engineering comprises source code and resources required by the execution of the source code;
the establishing unit is used for establishing a first file and a second file in the class library engineering;
a declaration unit, configured to declare an identifier of the resource in the first file;
a definition unit, configured to define, in the second file, an identifier of the resource;
wherein the declaration of the first file and the definition in the second file are for a reference to a customer application project.
7. The system of claim 6,
the system further comprises:
the first compiling unit is used for compiling the source code for the first time and generating a third file comprising the identification and the definition of the resource;
the declaration unit is specifically configured to select an identifier of a resource to be disclosed from the third file, and add the identifier to the first file;
the definition unit is specifically configured to select an identifier of a resource that needs to be disclosed from the third file, and add the identifier to the second file.
8. The system of claim 6 or 7,
the system further comprises:
the second compiling unit is used for compiling the source code for the second time based on the first file and the second file to form a compiled code;
a first forming unit, configured to form a resource directory based on the required resource;
and the second forming unit is used for packaging the compiled codes and the resource directory to form a code package.
9. The system of claim 8,
the system further comprises:
the second establishing unit is used for establishing a proxy project;
an adding unit, configured to add the first file, the second file, and the resource in an agent library of the agent project;
and the first reference unit is used for adding a reference to the code package in the proxy engineering.
10. The system of claim 9,
the system further comprises:
a third creating unit for creating a client application project;
and the second reference unit is used for referencing the proxy library in the client application project.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510589975.7A CN106547519B (en) | 2015-09-16 | 2015-09-16 | Information processing method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510589975.7A CN106547519B (en) | 2015-09-16 | 2015-09-16 | Information processing method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN106547519A CN106547519A (en) | 2017-03-29 |
| CN106547519B true CN106547519B (en) | 2020-02-04 |
Family
ID=58361554
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201510589975.7A Active CN106547519B (en) | 2015-09-16 | 2015-09-16 | Information processing method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN106547519B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109062548B (en) * | 2018-07-04 | 2020-06-30 | 中国地质大学（武汉） | Web service expansion method and system based on workflow construction |
| CN111737504B (en) * | 2020-06-23 | 2023-09-15 | 网易（杭州）网络有限公司 | Image resource detection method, device, equipment and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7770160B2 (en) * | 2003-02-28 | 2010-08-03 | Microsoft Corporation | System and method for declaring a resource within a markup document |
| CN101814032A (en) * | 2010-02-08 | 2010-08-25 | 河南大学 | Resource encapsulation method utilizing Delphi resource file to generate Windows application program |
| CN102184231A (en) * | 2011-05-12 | 2011-09-14 | 广州市动景计算机科技有限公司 | Method and device for acquiring page resources |
-
2015
- 2015-09-16 CN CN201510589975.7A patent/CN106547519B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7770160B2 (en) * | 2003-02-28 | 2010-08-03 | Microsoft Corporation | System and method for declaring a resource within a markup document |
| CN101814032A (en) * | 2010-02-08 | 2010-08-25 | 河南大学 | Resource encapsulation method utilizing Delphi resource file to generate Windows application program |
| CN102184231A (en) * | 2011-05-12 | 2011-09-14 | 广州市动景计算机科技有限公司 | Method and device for acquiring page resources |
Also Published As
| Publication number | Publication date |
|---|---|
| CN106547519A (en) | 2017-03-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10824442B2 (en) | Method and apparatus for loading multiple differing versions of a native library into a native environment | |
| CN106775723B (en) | Android platform-based system firmware customization method and Android device | |
| CN107168749B (en) | Compiling method, device, equipment and computer readable storage medium | |
| Dietrich et al. | Broken promises: An empirical study into evolution problems in java programs caused by library upgrades | |
| JP5475979B2 (en) | Method and apparatus for providing project development environment and project development system (method and apparatus for providing project development environment and project development system) | |
| CN113050954A (en) | Modular common version management in dynamically linked runtime environments | |
| US9459986B2 (en) | Automatic generation of analysis-equivalent application constructs | |
| CN110659031A (en) | Compiling method and device of application program, electronic equipment and storage medium | |
| WO2005024631A2 (en) | Creating and checking runtime data types | |
| CN112769706B (en) | Componentized routing method and system | |
| CN114217787A (en) | Development method and device of modular application program and storage medium | |
| CN109558121B (en) | Interface driver development method, device, equipment and storage medium | |
| CN106547519B (en) | Information processing method and system | |
| CN112882690A (en) | Application development method and device | |
| CN111552480A (en) | Cross-platform compiling method, device, equipment and readable storage medium | |
| CN115098158A (en) | SDK packaging method and device, computer equipment and storage medium | |
| CN115576560A (en) | Hot reloading method, device, equipment and medium for dynamic loader | |
| CN115658140A (en) | SDK packaging method, device, terminal and storage medium | |
| CN111580853A (en) | Universal generation method for multi-channel software installation package | |
| CN115686511A (en) | Cross-platform software development method and device based on cross-platform language | |
| CN114860204A (en) | Program processing method, program operating device, terminal, smart card and storage medium | |
| CN114816418A (en) | Method, device, equipment and medium for building embedded operating system | |
| CN111428209B (en) | Application program confusion method, device and storage medium | |
| CN110333870B (en) | Simulink model variable distribution processing method, device and equipment | |
| CN112052051A (en) | Plug-in processing method, device, equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |