CN107102866B - Native APP file generation method and device under iOS system and server - Google Patents
Native APP file generation method and device under iOS system and server Download PDFInfo
- Publication number
- CN107102866B CN107102866B CN201710404220.4A CN201710404220A CN107102866B CN 107102866 B CN107102866 B CN 107102866B CN 201710404220 A CN201710404220 A CN 201710404220A CN 107102866 B CN107102866 B CN 107102866B
- Authority
- CN
- China
- Prior art keywords
- file
- frame
- website
- native app
- writing
- 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
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/315—Object-oriented languages
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computing Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses a method, equipment, a server and a storage medium for generating a native APP file under an iOS system. The native APP file generation method comprises the following steps: generating an intermediate file for data exchange based on the website file; writing the data in the intermediate file into a preset frame file, wherein the frame file is written based on a programming language corresponding to a native APP file under a specific expected operating system; and generating a native APP file based on the frame file. Therefore, the frame file is written according to the programming language corresponding to the native APP file under the specific operating system expected to be generated in advance, when the native APP file is generated based on the website file, the website file can be firstly converted into an intermediate file suitable for data exchange, and then the native APP file can be quickly obtained by writing the data in the intermediate file into the frame file.
Description
Technical Field
The present invention relates to the field of APP application generation, and in particular, to a method, a device, a server, and a storage medium for generating a native APP file in an iOS system.
Background
A web site (Website) is a collection of web pages that are created on the internet using tools such as HTML (an application in standard universal markup language) according to certain rules to display specific content. In short, a website is a communication tool, through which people can publish information they want to disclose, or access the website through a web browser to obtain information they need or enjoy related services.
With the popularization of mobile terminal devices such as smart phones and IPADs, users tend to browse websites by using mobile browsers installed on mobile devices, but due to the fact that fragmentation of operating systems of existing mobile terminal devices such as mobile phones is serious, browsers of mobile terminal devices such as mobile phones have many differences, and browsers of different models are not smooth in webpage browsing effect, so that browsing experience of users can be reduced.
In addition, the number of native APPs generated for the operating system of a specific mobile terminal device is increasing, and since the native APPs operate independently based on the specific operating system, a user can obtain related contents without a browser, so that the native APPs gradually replace websites to become a first choice for the user to obtain information or enjoy related services on the mobile terminal device.
Therefore, a scheme capable of converting the website file into the native mobile APP software is needed to better meet the experience requirements of the user.
Disclosure of Invention
The invention mainly aims to provide a native APP file generation method, a device, a server and a storage medium, wherein the native APP file generation method, the device, the server and the storage medium can convert website files into native mobile APP software.
According to an aspect of the present invention, a native APP file generation method is provided, including: generating an intermediate file for data exchange based on the website file; writing the data in the intermediate file into a preset frame file, wherein the frame file is written based on a programming language corresponding to a native APP file under a specific expected operating system; and generating a native APP file based on the frame file.
Preferably, the step of generating an intermediate file for data exchange based on the website file may include: generating a first intermediate file for data exchange based on a website HTML file and a website CSS file, wherein the first intermediate file comprises HTML elements in the website HTML file and attributes of the HTML elements; generating a second intermediate file for data exchange based on the website event storage file, wherein the second intermediate file is composed of website event codes; and generating a third intermediate file for data exchange based on a preset interface template or an interface template selected by a user, wherein the third intermediate file is composed of APP interface codes.
Preferably, the step of writing the data in the intermediate file into the preset frame file may include: writing the data in the first intermediate file into the frame file; and/or writing the data in the second intermediate file into the frame file; and/or writing the data in the third intermediate file to the frame file.
Preferably, the frame file includes one or more controls, and the step of writing the data in the first intermediate file into the frame file may include: converting the attribute of the HTML element into the attribute of the control corresponding to the HTML element under the condition that the control corresponding to the HTML element in the first intermediate file exists in the frame file; and/or under the condition that the control corresponding to the HTML element in the first intermediate file does not exist in the frame file, generating a new control corresponding to the HTML element in the frame file, and converting the attribute of the HTML element into the attribute of the newly generated control.
Preferably, the step of writing the data in the second intermediate file into the frame file may include: converting the website event code into a corresponding APP event code, writing the APP event code into the frame file, and/or writing the data in the third intermediate file into the frame file may include: and writing the APP interface code into the frame file.
Preferably, the intermediate file is in the JSON data interchange format.
Preferably, the native APP file is an APP file under the iOS system, the frame file is a frame file edited based on object-c language, and the step of generating the native APP file based on the frame file includes: the frame file is converted into a file in IPA format.
According to another aspect of the present invention, there is also provided a native APP file generation apparatus, including: the intermediate file generating module is used for generating an intermediate file for data exchange based on the website file; the writing module is used for writing the data in the intermediate file into a preset frame file, wherein the frame file comprises one or more controls; and the native APP file generation module is used for generating a native APP file based on the frame file.
Preferably, the intermediate file generating module may include: the first intermediate file generation module is used for generating a first intermediate file for data exchange based on a website HTML file and a website CSS file, wherein the first intermediate file comprises an HTML element in the website HTML file and attributes of the HTML element; the second intermediate file generation module is used for generating a second intermediate file for data exchange based on the website event storage file, and the second intermediate file is composed of website event codes; the third intermediate file generation module is used for generating a third intermediate file for data exchange based on a preset interface template or an interface template selected by a user, and the third intermediate file is composed of APP interface codes; .
Preferably, the writing module may include: the first writing module is used for writing the data in the first intermediate file into the frame file; and/or a second writing module, configured to write data in the second intermediate file into the frame file; and/or the third writing module is used for writing the data in the third intermediate file into the frame file.
Preferably, the frame file comprises one or more controls, and in the case that a control corresponding to the HTML element in the first intermediate file exists in the frame file, the first writing module converts the attribute of the HTML element into the attribute of the control corresponding to the HTML element; and/or under the condition that the frame file does not have the control corresponding to the HTML element in the first intermediate file, the first writing module generates a new control corresponding to the HTML element in the frame file, and converts the attribute of the HTML element into the attribute of the newly generated control.
Preferably, the second writing module converts the website event codes into corresponding APP event codes and writes the APP event codes into the frame file, and/or the third writing module writes the APP interface codes into the frame file.
Preferably, the intermediate file is in the JSON data interchange format.
Preferably, the native APP file is an APP file under the iOS system, the frame file is a frame file edited based on object-c language, and the step of generating the native APP file based on the frame file includes: the frame file is converted into a file in IPA format.
According to another aspect of the present invention, there is also provided a server for generating native APP, comprising: a processor; and a memory having executable code stored thereon, which when executed by the processor, causes the processor to perform the above-mentioned native APP file generation method.
According to another aspect of the present invention, there is also provided a non-transitory machine-readable storage medium having stored thereon executable code, which when executed by a processor of an electronic device, causes the processor to perform the above-mentioned native APP file generation method.
According to the method, the device, the server and the storage medium for generating the native APP file, the frame file is written in advance based on the programming language corresponding to the native APP file under the specific operating system expected to be generated, when the native APP file is generated based on the website file, the website file can be firstly converted into the intermediate file suitable for data exchange, and then the data in the intermediate file is written into the frame file, so that the native APP file can be quickly obtained.
Drawings
The above and other objects, features and advantages of the present disclosure will become more apparent by describing in greater detail exemplary embodiments thereof with reference to the attached drawings, in which like reference numerals generally represent like parts throughout.
FIG. 1 is a schematic block diagram illustrating the structure of a server for generating native APP files in accordance with one embodiment of the present invention.
FIG. 2 is a schematic flow chart diagram illustrating a native APP file generation method in accordance with an embodiment of the present invention.
FIG. 3 is a schematic flow chart diagram illustrating a specific implementation process for writing an intermediate file to a skeleton file according to an embodiment of the invention.
FIG. 4 is a schematic block diagram illustrating the structure of a native APP file generation device in accordance with one embodiment of the present invention.
Detailed Description
Preferred embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While the preferred embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.
As described above, the present invention mainly provides a scheme for generating a native APP file from a website file. The website mentioned in the present invention may be a website that can be accessed by various terminal devices such as desktop computers, notebook computers, mobile phones, and IPADs. Since the layout, configuration files, etc. of the micro-station are designed for the mobile device, the website file based on the micro-station is easier to convert into a native APP file suitable for being executed on the mobile device, and thus, the website mentioned in the present invention is preferably a micro-station suitable for being browsed by a mobile browser installed on a mobile terminal.
Fig. 1 shows a schematic block diagram of the structure of a server 100 according to an embodiment of the present invention.
The server 100 of the present invention may be a terminal server or a mobile terminal device. Such as a mobile computer or mobile computing device (e.g., tablet computer, personal digital assistant, laptop computer, notebook computer, netbook, etc.), mobile phone (e.g., smartphone), wearable computing device (e.g., smartwatch, smartglasses, etc.), or other type of mobile device. The components of server 100 include, but are not limited to, a processor 110 and a memory 120.
The memory 120 may include one or more of a variety of types of storage devices that store content in file form or other form, including magnetic hard drives, solid state hard drives, semiconductor storage devices, flash memory, or any other computer readable writable storage medium capable of storing program instructions or digital information.
The memory 120 may have executable code stored thereon that may be executed by the processor 110. The executable code, when executed by the processor 110, may cause the processor 110 to perform a native APP file generation method according to the present invention, which will be described in detail below in conjunction with fig. 2 and 3.
FIG. 2 is a schematic flow chart diagram illustrating a native APP file generation method in accordance with an embodiment of the present invention.
Referring to fig. 2, in step S210, an intermediate file for data exchange is generated based on a website file.
The website file mentioned herein refers to a related file formed by designing and developing a website, and may include, for example, a website HTML file, a website CSS file, a website event storage file, and the like.
Based on the website file, the website file can be converted into an intermediate file suitable for data exchange, so that data can be exchanged according to the intermediate file subsequently. The intermediate file may be a file in a variety of data exchange formats, for example, the intermediate file may be a file in a JSON (JSON object markup) data exchange format. The process of generating an intermediate file in a specific data exchange format (e.g., JSON) based on a website file is well known to those skilled in the art and will not be described herein.
In step S220, the data in the intermediate file is written into a preset frame file.
The framework file mentioned herein may be a pre-edited file based on a certain programming language. Specifically, the framework file may be edited based on the programming language corresponding to the native APP file under the particular operating system that is desired to be generated. For example, when it is desired to generate a native APP file under the iOS system, the frame file can be edited based on the object-c language. In addition, for other operating systems similar to the iOS system, the framework file may also be written based on a programming language corresponding to the operating system, which is not described herein again.
The edited frame file may include one or more controls. The control mentioned here may be a control commonly used by the native APP, such as an input box control, a search bar control, a navigation bar control, and so on, where the property of the control may be set to be null or not (the property value may be randomly set).
Since the intermediate file is a file in a data exchange format generated based on the website file, the data in the intermediate file can be written into the framework file. For example, the properties of the relevant element in the intermediate file may be written to the control corresponding to the element. When the attribute of the control in the frame file is empty, the control can be directly written in, and when the attribute of the control in the frame file is not empty, the control can be replaced. The specific process of writing the data in the intermediate file into the frame file will be described in detail below, and will not be described herein again.
In step S230, a native APP file is generated based on the framework file.
Since the frame file is edited based on the programming language corresponding to the operating system of the native APP file desired to be generated, the compiling step can be omitted, and the frame file is directly converted into the native APP file corresponding to the format of the specific operating system. For example, when it is desired to generate native APP files under the iOS system, the framework files may be converted to IPA formatted files. In addition, for other operating systems similar to the iOS system, the operating systems can also be converted into files in corresponding formats, which are not described herein again.
In summary, according to the primary APP file generation scheme of the present invention, the frame file is written in advance based on the programming language corresponding to the primary APP file under the specific operating system that is expected to be generated, and when the primary APP file is generated based on the website file, the website file may be first converted into an intermediate file suitable for data exchange, and then the data in the intermediate file is written into the frame file, so that the primary APP file may be obtained. The generated native APP file can directly inform a user of downloading, and can also be submitted to a developer for secondary development, so that part of development cost is saved.
FIG. 3 is a schematic flow chart diagram illustrating a specific implementation process for writing an intermediate file to a skeleton file.
Referring to fig. 3, a first intermediate file for data exchange may be generated based on a website HTML file and a website CSS file, and the first intermediate file may include HTML elements in the website HTML file and attributes of the HTML elements.
As described above, one or more controls may be included in the frame file, so that in the process of writing the data in the first intermediate file into the frame file, for a certain HTML element, the attribute of the certain HTML element may be converted into the attribute of the control corresponding to the HTML element. Under the condition that the frame file does not have the control corresponding to the HTML element, a new control can be generated in the frame file, and then the attribute of the HTML element is converted into the attribute of the newly generated control.
Referring to fig. 3, a second intermediate file for data exchange may also be generated based on the website event storage file, and the second intermediate file may be composed of a website event code.
The website event storage file may store various website events, such as operation events related to user operations, such as clicking and long-pressing, and response events, such as skip and pop-up prompts, performed in response to user operations. Here, various website events stored in the website event storage file may be converted into website event codes. For example, it can be converted into a file in HTML format.
When the second intermediate file is written into the frame file, the website event codes constituting the second intermediate file may be converted into corresponding APP event codes to be written into the frame file. In particular, the website event code may be converted into code corresponding to the native APP file under the particular operating system that is desired to be generated. For example, when it is desired to generate a native APP file under the iOS system, the website event code may be converted into APP code in the object-c language. In addition, for other operating systems similar to the iOS system, the website event code may also be converted into APP code corresponding to the programming language of the other operating systems, which is not described herein again.
Referring to fig. 3, a third intermediate file for data exchange may also be generated based on a predetermined interface template or an interface template selected by a user, and the third intermediate file may be composed of APP interface codes. The APP interface code may be a code corresponding to a native APP file under a specific operating system that is desired to be generated, and at this time, the APP interface code may be directly written into the framework file.
In summary, the native APP file can be dynamically generated by writing the first intermediate file, the second intermediate file, and the third intermediate file into the frame file. The native APP files referred to herein may be native APP installation files, such as native APP compact installation packages.
Now, the flow of the native APP file generation method of the present invention is described in detail with reference to fig. 2 and 3. Corresponding to the native APP file generation method, the invention also provides a native APP file generation device.
FIG. 4 is a functional block diagram illustrating the structure of a native APP file generation device in accordance with one embodiment of the present invention. The functional modules of the native APP file generation apparatus 400 may be implemented by hardware, software, or a combination of hardware and software that implement the principles of the present invention. It will be appreciated by those skilled in the art that the functional blocks described in fig. 4 may be combined or divided into sub-blocks to implement the principles of the invention described above. Thus, the description herein may support any possible combination, or division, or further definition of the functional modules described herein.
The native APP file generating device 400 shown in fig. 4 may be used to implement the native APP file generating method shown in fig. 2 and fig. 3, and only the functional modules that the native APP file generating device 400 may have and the operations that each functional module may perform are briefly described below, and for the details involved therein, the description in conjunction with fig. 2 and fig. 3 may be referred to, and details are not repeated here.
Referring to fig. 4, the native APP file generation apparatus 400 includes an intermediate file generation module 410, a write module 420, and an element APP file generation module 430.
The intermediate file generating module 410 is configured to generate an intermediate file for data exchange based on the website file.
The writing module 420 is configured to write the data in the intermediate file into a preset frame file, where the frame file is written based on a programming language corresponding to the native APP file under a specific operating system that is expected to be generated.
The native APP file generation module 430 is configured to generate a native APP file based on the framework file.
As shown in fig. 4, the intermediate file generating module 410 may optionally include a first intermediate file generating module 411, a second intermediate file generating module 413, and a third intermediate file generating module 415, which are indicated by dashed boxes in the figure.
The first intermediate file generating module 411 is configured to generate a first intermediate file for data exchange based on the website HTML file and the website CSS file, where the first intermediate file includes an HTML element in the website HTML file and an attribute of the HTML element;
the second intermediate file generating module 413 is configured to generate a second intermediate file for data exchange based on the website event storage file, where the second intermediate file is formed by website event codes;
the third intermediate file generating module 415 is configured to generate a third intermediate file for data exchange based on a predetermined interface template or an interface template selected by a user, where the third intermediate file is composed of APP interface codes.
As shown in fig. 4, the writing module 420 may further optionally include a first writing module 421, a second writing module 423, and a third writing module 425 shown by dashed boxes.
The first writing module 421 is configured to write the data in the first intermediate file into the frame file, the second writing module 423 is configured to write the data in the second intermediate file into the frame file, and the third writing module 425 is configured to write the data in the third intermediate file into the frame file.
Specifically, the frame file may include one or more controls, and in the case where a control corresponding to an HTML element in the first intermediate file exists in the frame file, the first writing module 421 may convert the attribute of the HTML element into the attribute of the control corresponding to the HTML element. In the case where there is no control corresponding to the HTML element in the first intermediate file in the frame file, the first writing module 421 may generate a new control corresponding to the HTML element in the frame file, and then convert the attribute of the HTML element into the attribute of the newly generated control.
The second writing module 423 may convert the website event codes into corresponding APP event codes and write the APP event codes into the frame file, and the third writing module 425 may write the APP interface codes into the frame file.
The native APP file generation method, apparatus, and server according to the present invention have been described in detail above with reference to the accompanying drawings.
Those skilled in the art will clearly understand that the techniques in the embodiments of the present invention may be implemented by software plus necessary general hardware, including general purpose integrated circuits, general purpose CPUs, general purpose memories, general purpose components, etc., or by special purpose hardware, including special purpose integrated circuits, special purpose CPUs, special purpose memories, special purpose components, etc., but the former is a better implementation in many cases. Based on such understanding, the technical solutions in the embodiments of the present invention may be substantially implemented or portions thereof that contribute to the prior art may be embodied in the form of a software product, which may be stored in a storage medium, such as a Read-only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, an optical disk, and the like, and includes several instructions to enable a computer device (which may be a personal computer, a server, or a network device) to execute the method in each embodiment or some portions thereof.
Accordingly, the above technical concept of the present invention can also be embodied as a non-transitory machine-readable storage medium (or computer-readable storage medium) having executable codes (or computer program/computer instruction codes) stored thereon. The executable code (or computer program/computer instruction code), when executed by a processor, causes the processor to perform the native APP file generation method described above.
In another aspect, the above technical concept of the present invention may also be embodied as a computing device including a processor and a non-transitory machine-readable storage medium (or computer-readable storage medium). The non-transitory machine-readable storage medium has executable code (or computer program/computer instruction code) stored thereon. The executable code (or computer program/computer instruction code), when executed by the processor, causes the processor to perform the native APP file generation method described above.
Furthermore, the method according to the invention may also be implemented as a computer program comprising computer program code instructions for carrying out the above-mentioned steps defined in the above-mentioned method of the invention. Alternatively, the method according to the present invention may also be implemented as a computer program product comprising a computer readable medium having stored thereon a computer program for executing the above-mentioned functions defined in the above-mentioned method of the present invention. Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the disclosure herein may be implemented as electronic hardware, computer software, or combinations of both.
The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems and methods according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
Having described embodiments of the present invention, the foregoing description is intended to be exemplary, not exhaustive, and not limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen in order to best explain the principles of the embodiments, the practical application, or improvements made to the technology in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.
Claims (14)
1. A native APP file generation method under an IOS system comprises the following steps:
converting the website file into an intermediate file for data exchange, wherein the intermediate file is a JSON data exchange format file, and the website file refers to a related file formed by designing and developing websites;
writing the data in the intermediate file into a preset frame file, wherein the frame file is written based on a programming language corresponding to a native APP file under the IOS system;
converting the frame file into a native APP file corresponding to a format of the IOS system.
2. The native APP file generation method of claim 1, wherein the step of generating an intermediate file for data exchange based on a website file comprises:
generating a first intermediate file for data exchange based on a website HTML file and a website CSS file, wherein the first intermediate file comprises an HTML element in the website HTML file and attributes of the HTML element;
generating a second intermediate file for data exchange based on the website event storage file, wherein the second intermediate file is composed of website event codes;
and generating a third intermediate file for data exchange based on a preset interface template or an interface template selected by a user, wherein the third intermediate file is composed of APP interface codes.
3. The native APP file generation method of claim 2, wherein the writing of data in the intermediate file into a pre-set frame file comprises:
writing the data in the first intermediate file into the frame file; and/or
Writing the data in the second intermediate file into the frame file; and/or
And writing the data in the third intermediate file into the frame file.
4. The native APP file generation method of claim 3, wherein the frame file includes one or more controls, and writing the data in the first intermediate file to the frame file comprises:
converting the attribute of the HTML element into the attribute of the control corresponding to the HTML element under the condition that the control corresponding to the HTML element in the first intermediate file exists in the frame file; and/or
And under the condition that the control corresponding to the HTML element in the first intermediate file does not exist in the frame file, generating a new control corresponding to the HTML element in the frame file, and converting the attribute of the HTML element into the attribute of the newly generated control.
5. The native APP file generation method of claim 3,
the step of writing the data in the second intermediate file into the frame file comprises: converting the website event code into a corresponding APP event code, writing the APP event code into the frame file, and/or
The step of writing the data in the third intermediate file into the frame file comprises: and writing the APP interface code into the frame file.
6. The native APP file generation method of any one of claims 1 to 5, wherein the skeleton file is edited based on object-c language, and the step of generating the native APP file based on the skeleton file comprises: and converting the frame file into an IPA format file.
7. A native APP file generation device under an IOS system comprises:
the system comprises an intermediate file generation module, a data exchange module and a data exchange module, wherein the intermediate file generation module is used for converting a website file into an intermediate file for data exchange, the intermediate file is a JSON data exchange format file, and the website file is a related file formed by a design and development website;
the writing module is used for writing the data in the intermediate file into a preset frame file, wherein the frame file is written based on a programming language corresponding to a native APP file under an IOS system;
and the native APP file generation module is used for converting the frame file into a native APP file corresponding to the format of the IOS system.
8. The native APP file generation device of claim 7, wherein the intermediate file generation module comprises:
the first intermediate file generation module is used for generating a first intermediate file for data exchange based on a website HTML file and a website CSS file, wherein the first intermediate file comprises an HTML element in the website HTML file and attributes of the HTML element;
the second intermediate file generation module is used for generating a second intermediate file for data exchange based on the website event storage file, wherein the second intermediate file is composed of website event codes;
and the third intermediate file generation module is used for generating a third intermediate file for data exchange based on a preset interface template or an interface template selected by a user, wherein the third intermediate file is composed of APP interface codes.
9. The native APP file generation device of claim 8, wherein the write module comprises:
the first writing module is used for writing the data in the first intermediate file into the frame file; and/or
The second writing module is used for writing the data in the second intermediate file into the frame file; and/or
And the third writing module is used for writing the data in the third intermediate file into the frame file.
10. The native APP file generation device of claim 9, wherein the framework file includes one or more controls,
in the case that a control corresponding to an HTML element in the first intermediate file exists in the frame file, the first writing module converts the attribute of the HTML element into the attribute of the control corresponding to the HTML element; and/or
And under the condition that the frame file does not have the control corresponding to the HTML element in the first intermediate file, the first writing module generates a new control corresponding to the HTML element in the frame file and converts the attribute of the HTML element into the attribute of the newly generated control.
11. The native APP file generation apparatus of claim 9,
the second writing module converts the website event codes into corresponding APP event codes and writes the APP event codes into the frame file, and/or
And the third writing module writes the APP interface code into the frame file.
12. The native APP file generation apparatus according to any one of claims 7 to 11, wherein the skeleton file is a skeleton file edited based on object-c language, and the step of generating the native APP file based on the skeleton file includes: and converting the frame file into an IPA format file.
13. A server for generating a native APP file, comprising:
a processor; and
memory having stored thereon executable code which, when executed by the processor, causes the processor to perform the native APP file generation method of any one of claims 1 to 6.
14. A non-transitory machine-readable storage medium having stored thereon executable code that, when executed by a processor of an electronic device, causes the processor to perform the native APP file generation method of any of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710404220.4A CN107102866B (en) | 2017-06-01 | 2017-06-01 | Native APP file generation method and device under iOS system and server |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710404220.4A CN107102866B (en) | 2017-06-01 | 2017-06-01 | Native APP file generation method and device under iOS system and server |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN107102866A CN107102866A (en) | 2017-08-29 |
| CN107102866B true CN107102866B (en) | 2021-05-25 |
Family
ID=59659149
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710404220.4A Active CN107102866B (en) | 2017-06-01 | 2017-06-01 | Native APP file generation method and device under iOS system and server |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107102866B (en) |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| GB2523074A (en) * | 2013-12-16 | 2015-08-19 | Make Apps Better Ltd | A method and system for modifying deployed applications |
| CN106293311A (en) * | 2015-05-26 | 2017-01-04 | 阿里巴巴集团控股有限公司 | Page display method based on Mobile solution, client, server and platform |
Family Cites Families (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7877727B2 (en) * | 2006-08-18 | 2011-01-25 | Bitrouter | Hierarchical state programming with a markup language |
| IN2012CH04482A (en) * | 2012-10-26 | 2015-06-19 | Exceed Technology Solutions Private Ltd I | |
| CN105278971A (en) * | 2014-06-17 | 2016-01-27 | 中国移动通信集团浙江有限公司 | Mobile terminal installation package batch generation method and device |
| CN105468324A (en) * | 2015-12-25 | 2016-04-06 | 北京奇虎科技有限公司 | Page display method, device and system |
| CN106055716A (en) * | 2016-07-13 | 2016-10-26 | 北京智网易联科技有限公司 | Method and equipment for automatically generating website |
| CN106227517B (en) * | 2016-07-13 | 2019-09-06 | 北京智网易联科技有限公司 | Primary mobile APP software auto generating method and equipment |
-
2017
- 2017-06-01 CN CN201710404220.4A patent/CN107102866B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| GB2523074A (en) * | 2013-12-16 | 2015-08-19 | Make Apps Better Ltd | A method and system for modifying deployed applications |
| CN106293311A (en) * | 2015-05-26 | 2017-01-04 | 阿里巴巴集团控股有限公司 | Page display method based on Mobile solution, client, server and platform |
Non-Patent Citations (1)
| Title |
|---|
| Wireless data transmission between iOS client and web server;Baoqin Liu ET AL;《 2014 9th International Conference on Computer Science & Education》;20141016;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN107102866A (en) | 2017-08-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| TWI703463B (en) | Information display method, device and intelligent terminal | |
| CN102567516B (en) | Script loading method and device | |
| CN110941784A (en) | Page generation method and device | |
| US20190340230A1 (en) | System and method for generating websites from predefined templates | |
| US9507480B1 (en) | Interface optimization application | |
| CN102693280A (en) | Webpage browsing method, WebApp framework, method and device for executing JavaScript, and mobile terminal | |
| CN104142826A (en) | Method, device and system for constructing page | |
| CN104731589A (en) | Automatic generation method and device of user interface (UI) | |
| CN106294658A (en) | The quick methods of exhibiting of webpage and device | |
| CN107479868B (en) | Interface loading method, device and equipment | |
| CN111796821A (en) | Page updating method and device | |
| CN110941779B (en) | Page loading method and device, storage medium and electronic equipment | |
| US20190197067A1 (en) | Normalizing a page flow | |
| CN102622376A (en) | Method and equipment used for merging cascading style sheet files | |
| CN113127361A (en) | Application program development method and device, electronic equipment and storage medium | |
| CN113110829A (en) | Multi-UI component library data processing method and device | |
| CN113760276A (en) | Method and device for generating page code | |
| CN110618811B (en) | Information presentation method and device | |
| CN109857503B (en) | Page interaction effect self-adaption method and device and electronic equipment | |
| CN107102866B (en) | Native APP file generation method and device under iOS system and server | |
| CN113253996B (en) | Card construction method, electronic device, server and storage medium | |
| CN107918552B (en) | Light application calling method and device, client device and electronic equipment | |
| CN112256991B (en) | Method and equipment for native rendering of information flow fusing multiple link addresses | |
| WO2019047881A1 (en) | Page display method and apparatus for application program (app), device, and storage medium | |
| CN114329152A (en) | Application program generation method, device, equipment and medium based on browser engine |
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 |