CN112286504A - Method for realizing development and loading of small program based on Reactnative in mobile APP - Google Patents
Method for realizing development and loading of small program based on Reactnative in mobile APP Download PDFInfo
- Publication number
- CN112286504A CN112286504A CN202011258251.1A CN202011258251A CN112286504A CN 112286504 A CN112286504 A CN 112286504A CN 202011258251 A CN202011258251 A CN 202011258251A CN 112286504 A CN112286504 A CN 112286504A
- Authority
- CN
- China
- Prior art keywords
- applet
- file
- reactnative
- project
- loading
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 43
- 238000004806 packaging method and process Methods 0.000 claims abstract description 15
- 238000012856 packing Methods 0.000 claims abstract description 11
- 230000006870 function Effects 0.000 claims description 9
- 230000009191 jumping Effects 0.000 claims description 4
- 230000008859 change Effects 0.000 claims description 3
- 230000008569 process Effects 0.000 description 7
- 238000010276 construction Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 238000005538 encapsulation Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 239000012634 fragment Substances 0.000 description 2
- 230000007547 defect Effects 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000009977 dual effect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000009877 rendering Methods 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
Abstract
The invention relates to a method for realizing development and loading of an applet in a mobile APP based on ReactNative, which comprises the steps of creating the applet and an internal file according to an attached drawing directory structure, wherein the internal file comprises an entry file, a project description file, a project code, a project dependence description file and a project packaging configuration file; debugging a base support package and reference; developing an applet; packing and running the small program compiling; and running the small program. The method for developing and loading the applet based on the ReactNative in the mobile APP is adopted, and the development method of the applet based on the ReactNative is provided, so that the applet can be developed by using the ReactNative grammar, and meanwhile, proprietary deployment and the issuing and management of the applet can be carried out without depending on three-party manufacturers. The invention also provides a small program packaging method based on the ReactNative, thereby realizing packaging of the ReactNative project into an independent small program project and realizing the problem that the native App loads the ReactNative small program.
Description
Technical Field
The invention relates to the field of mobile App, in particular to the field of applet development based on Reactnative, and specifically relates to a method for realizing applet development and loading based on Reactnative in mobile APP.
Background
In the current mobile internet era, the number of apps in App stores is increasing, but the number of apps commonly used by users in mobile devices is limited, so that how to manage functions in a single App is also an increasing problem to be solved. Similarly, a large number of web applications inside an enterprise need to be implemented on a mobile side, and how to develop, manage and publish the web applications also needs a new architecture to solve.
Therefore, many enterprise business applications are managed by a small program framework, function codes are developed by using a ReactNative or Vue or Html5 mode and are released and updated in a resource package mode, the page effect superior to H5 can be guaranteed, the problem of cross-platform development can be solved, only one code is needed to run under an Android and iOS dual platform, developers can develop and iterate rapidly, and rapid online is achieved.
At present, a small program model on the market is mostly based on an html5 technology, page and logic development is carried out by writing html5+ js + css3 codes, a page is rendered and loaded through native webview, a unified UI style is realized through expansion of the native webview, and calling of native capability through js codes is realized through bridging of the webview. And packaging the developed codes into an html offline package form for management, and managing, auditing and distributing by a platform to achieve quick update of the version by the cloud.
The small program rendering generally adopts a JavaScript + Webview mode, a manufacturer provides a JavaScript + Native mode, and a Native rendering control is adopted in a scene with high performance requirements, so that better experience is provided for a user.
The description file of the applet generally adopts a json format and mainly describes information such as basic data of the applet, an applet dependency library version, used components and the like, and also some network and security configurations, wherein the metadata belongs to the applet and is in one-to-one correspondence with the application Id of the applet.
Meanwhile, the implementation mode of the applet scheme in the industry is also based on vue codes directly, namely, vue technology is used for writing application, and the application is packaged into a zip resource package as an applet medium after development is completed, so that platform management and release are realized.
At present, the applets include WeChat and Paobao applets and the like provided by manufacturers such as Tencent and Ali, and also include a scheme for privately deploying the applets in an intranet provided by manufacturers such as Puyuan.
In the prior art, by taking small programs such as WeChat and Paibao as examples, the development language of the small programs is not the standard JS + CSS + Html5 language, but the small programs have own encapsulation, for example, common Html tags and dom methods cannot be used, CSS is slightly different from the grammar of standard CSS, and components and api using the encapsulation need to be learned. This results in a large amount of extra learning cost. By using the method and the system, the pure ReactNative grammar can be used for developing the small programs, and rapid development and rapid iteration can be realized.
The existing applets, such as the WeChat applet and the Payment small program, are all deployed in a manufacturer server, version release also needs to be checked by the manufacturer, so that the application in an enterprise is limited, and the application in the enterprise is unsafe to the enterprise when the applets are deployed in the manufacturer server.
Disclosure of Invention
The invention aims to overcome the defects of the prior art and provides a method for realizing development and loading of small programs based on ReactNative in mobile APP, which has the advantages of simple structure, unified development language and wider application range.
In order to achieve the above purpose, the method for implementing applet development and loading based on the ReactNative in the mobile APP of the present invention is as follows:
the method for realizing development and loading of the applet in the mobile APP based on the Reactnative is mainly characterized by comprising the following steps:
(1) creating an applet and an internal file according to a drawing directory structure, wherein the applet and the internal file comprise an entry file, a project description file, a project code, a project dependence description file and a project packaging configuration file;
(2) debugging a base support package and reference;
(3) developing an applet;
(4) packing and running the small program compiling;
(5) and running the small program.
Preferably, the step (2) specifically comprises the following steps:
(2.1) debugging the base and the support package, and calling and installing relevant dependencies and quoting the support package;
(2.2) starting the debugging service, reading the item description file, and setting the item route as an applet entry file;
(2.3) developing page contents through a UI framework provided by the support package.
Preferably, the step (2.2) specifically comprises the following steps:
(2.2.1) judging whether the development mode is in the development mode, if so, continuing the step (2.2.2); otherwise, continuing (2.2.3);
(2.2.2) in a development mode, displaying a debugging home page provided by the support packet, displaying a list of the current debugging small program and the latest debugging small program, providing a configuration debugging IP and a port, and connecting and calling a service by a base after the configuration is finished;
and (2.2.3) in a non-development mode, loading a corresponding media file by the support packet according to the packaged configuration entry applet parameters, and jumping to a corresponding page by the support packet through route navigation according to the applet appId and the entry module name after loading.
Preferably, the step (3) specifically includes the following steps:
(3.1) developing small programs in the debugging base, connecting debugging service after a support package configures addresses in the debugging base, and providing a compiled product resource package of all files of the project;
and (3.2) compiling in real time when the file in the item directory changes, and synchronizing to a debugging base.
Preferably, the step (3.1) specifically comprises the following steps:
(3.1.1) compiling the single file;
and (3.1.2) debugging service is carried out, and functions of file change real-time updating, page refreshing, breakpoint debugging and network data viewing are provided.
Preferably, the step (4) specifically includes the following steps:
compiling and packing are carried out, all files under the project are scanned, the files under the project directory are compiled into corresponding modules, module codes of js files are collected to generate index.
Preferably, the module compiled in step (4) includes a page implementation code, a page unique identifier, and a page dependency module, and the content of the module compiled from the non-js file includes information of a resource file path, a resource name, and a resource suffix name.
Preferably, the step (5) is specifically:
finding a zip resource package locally according to the applet appId, loading an index.jsbundle file in the resource package, reading an applet entrance page homepage parameter, and loading a page through a ReactNative root route to realize the loading of an applet main interface.
Preferably, the internal file in step (1) includes an entry file, an item description file, an item code, an item dependency description file, and an item packaging configuration.
The method for developing and loading the applet based on the ReactNative in the mobile APP is adopted, and the development method of the applet based on the ReactNative is provided, so that the applet can be developed by using the ReactNative grammar, and meanwhile, proprietary deployment and the issuing and management of the applet can be carried out without depending on three-party manufacturers. The invention also provides a small program packaging method based on the ReactNative, thereby realizing packaging of the ReactNative project into an independent small program project and realizing the problem that the native App loads the ReactNative small program.
Drawings
Fig. 1 is a flowchart of a method for implementing applet development and loading based on ReactNative in mobile APP according to the present invention.
Fig. 2 is a schematic view of an applet directory structure of the method for implementing applet development and loading based on ReactNative in mobile APP of the present invention.
Fig. 3 is a schematic diagram of an applet support package of the method for implementing applet development and loading based on ReactNative in mobile APP of the present invention.
Fig. 4 is a schematic view of an applet architecture of a method for implementing applet development and loading based on ReactNative in mobile APP according to the present invention.
Detailed Description
In order to more clearly describe the technical contents of the present invention, the following further description is given in conjunction with specific embodiments.
The invention discloses a method for realizing development and loading of an applet in a mobile APP based on ReactNative, which comprises the following steps:
(1) creating an applet and an internal file according to a drawing directory structure, wherein the applet and the internal file comprise an entry file, a project description file, a project code, a project dependence description file and a project packaging configuration file;
(2) debugging a base support package and reference;
(2.1) debugging the base and the support package, and calling and installing relevant dependencies and quoting the support package;
(2.2) starting the debugging service, reading the item description file, and setting the item route as an applet entry file;
(2.2.1) judging whether the development mode is in the development mode, if so, continuing the step (2.2.2); otherwise, continuing (2.2.3);
(2.2.2) in a development mode, displaying a debugging home page provided by the support packet, displaying a list of the current debugging small program and the latest debugging small program, providing a configuration debugging IP and a port, and connecting and calling a service by a base after the configuration is finished;
(2.2.3) in a non-development mode, loading a corresponding media file by the support packet according to the packaged configuration entry applet parameters, and jumping to a corresponding page by the support packet through route navigation according to the applet appId and the entry module name after the loading is finished;
(2.3) developing page contents through a UI framework provided by the support package;
(3) developing an applet;
(3.1) developing small programs in the debugging base, connecting debugging service after a support package configures addresses in the debugging base, and providing a compiled product resource package of all files of the project;
(3.1.1) compiling the single file;
(3.1.2) debugging service is carried out, and functions of file change real-time updating, page refreshing, breakpoint debugging and network data viewing are provided;
(3.2) compiling in real time when the files in the project catalog are changed, and synchronizing the files in the debug base;
(4) packing and running the small program compiling;
compiling and packing are carried out, all files under the project are scanned, the files under the project directory are compiled into corresponding modules, module codes of js files are collected to generate index.
(5) Running the small program;
finding a zip resource package locally according to the applet appId, loading an index.jsbundle file in the resource package, reading an applet entrance page homepage parameter, and loading a page through a ReactNative root route to realize the loading of an applet main interface.
As a preferred embodiment of the present invention, the module compiled in step (4) includes a page implementation code, a page unique identifier, and a page dependency module, and the content of the module compiled from the non-js file includes information of a resource file path, a resource name, and a resource suffix name.
As a preferred embodiment of the present invention, the internal file in step (1) includes an entry file, an item description file, an item code, an item dependency description file, and an item packaging configuration.
In the specific implementation mode of the invention, in the current mobile internet era, the development requirements of mobile apps are more and more, but the number of apps accepted by users is limited, so the invention provides a method for realizing applets based on ReactNative, and a plurality of applets are loaded in one native App.
The invention realizes the development of the small program application by using the ReactNative language through the extension of the ReactNative application, realizes the connection with debugging service in a development mode through the support packet provided by the invention, refreshes the page in real time through code modification, compiles the ReactNative small program into a resource packet in a production mode, and realizes the loading of the small program resource packet by the native App.
With the rapid development of the mobile internet, the applet not only opens a new gate for the flow of developers, but also gets the favor of enterprises, and the applet architecture has gradually become the main development direction in the enterprises.
The invention takes the construction process of the applet framework in the informatization construction process of a certain company as a specific embodiment, and the realization method of the applet based on Reactnative comprises the following steps:
in a traditional large-scale enterprise, a large number of business processes are accumulated, and a large number of business systems are corresponding to the business processes, so that under the trend of mobile office, the business mobility in the enterprise also becomes an important step in information construction. In order to uniformly manage the service functions, the method is realized in the form of a ReactNative applet.
The technical scheme provides a method for realizing the applet based on ReactNative, and processes such as an applet project structure, a debugging base and a support package, applet development, applet compiling and packaging, applet running and the like are described in detail.
1. Creating an applet:
1.1, firstly, creating an applet according to a drawing directory structure, wherein the applet comprises five parts of an entry file, an item description file, an item code, an item dependency description file and an item packaging configuration.
1.2, the entry file is located in a root directory, is a js format file, the content is a development kit in a dependence section 3, and provides an entry for ReactNative debugging, and the entry is used as a project entry file for development and compilation.
1.3, the item description file is located under the item root directory/config and is a file in json format, wherein parameters such as appId (applet application id), appstyle (application type, default is reactivative), appName (applet name), homepage (applet entry page), icon (applet icon), version (applet version number), and buildId (applet compilation number) are declared.
1.4, the project codes are in an src folder under the project root path and comprise a home page routing statement, page codes, component codes and the like, and all files under the folder are compiled by a compiling script.
Json file under the root directory, in which all packages and components on which the applet depends and its version are declared.
1.6, item packing configuration is under a root directory/config/built _ config, four types of packing environments including dev, site, uat and pro and configuration exist according to different packing environments, wherein main configuration description exists in a json file form, application icon, startup icon and the like exist in a file form, and a packing script uses different configurations according to different environments.
2. Debugging base support package and reference:
and 2.1, the debugging base and the support package provide support for the development, debugging and compiling stages of the small program, and the small program calls the npm install related dependency and reference support package after being created.
2.2, when the debugging service is started, the support package reads the 1.3 project description file and sets the project route as the applet entry file.
And 2.3, in a development mode, displaying a debugging home page provided by the support package when entering the debugging base, wherein the debugging home page can display the currently debugged applet and the latest debugged applet list and provide the functions of configuring the debugging IP and the port, and the base can be connected with the service of calling after the configuration is finished.
And 2.4, in a non-development mode, after entering App, loading a media file index of a corresponding applet according to a packaged configuration applet appId and a homepage parameter by a support packet, and jumping to a corresponding page through route navigation according to the applet appId and an entry module name after the loading is finished.
Json file under the root directory, in which all packages and components that the applet depends on and its version are declared.
2.6, the support package provides a universal UI framework, only page content needs to be developed, the universal head navigation style of the page is provided by the support package in a unified way, and the same style and the function of customized extension are provided.
3. And (3) small program development:
3.1, the development of the small program is carried out in a debugging base, the support package in the section 2 is connected with debugging service after the debugging base is configured with addresses, a resource package object is produced by compiling all files of the project, and the small program is compiled in real time when the files in the project directory are changed (modified, newly added and deleted) and is synchronized into the debugging base.
3.2, the development of the small program provides the same experience as the ReactNative development, and is compatible with the ReactNative grammar.
3.3, the debugging service in (3.1) comprises two parts, one part is compilation of a single file, including js and png, mp3 and other resource files, and the js file is compiled into an index. The other part is debugging service of ReactNative, and functions of file modification real-time updating, page refreshing, breakpoint debugging, network data viewing and the like are provided.
3.4, when a three-party component is needed in the development process, a debugging base is needed to integrate the component, the dependency is added in the applet package json, and npm install is repeated.
And 3.5, depending on the debugging service (3.3), the debugging base can load and display the current debugging small program and refresh the page in real time when the file is changed.
4. And (3) small-program compiling and packaging operation:
and 4.1, compiling and packaging the small program after the development is finished, scanning all files under the project during compiling, compiling each js file to generate a module with a unique identifier, collecting module codes of all js files to generate an index.
4.2, the unique identifier generation rule in (4.1) is appId plus file relative path, for example, appId is com.mobile. portal app, file relative path/src/mainpage.js, and the generated unique identifier is/com.mobile. portal app/src/mainpage.js.
4.3, the module in (4.1) is the product of compiling the js file, and the fragments are as follows:
and 4.4, the page compiling module comprises a page implementation code, a page unique identifier and other modules depending on the page.
4.5, non-js files under the project directory are also compiled into modules, but the contents are information of the resource, such as resource file path, resource name, resource suffix name, etc., and the fragments are as follows:
4.6, the resource file is copied to the compilation product after it is compiled into a module, where the directory structure is consistent with the path of the file in the project.
4.6, only the files under the item directory will be compiled into the corresponding modules, and the components on which the pages depend will not be compiled, which is partly realized by the main bundle of the debugging base. And compiling products of all ReactNative and three-party component packages only exist in the main bundle, and loading is finished before the applet is loaded when the App is started.
4.7, the applet item can be compiled into native Android and iOS application, the applet is compiled into a zip package product, the zip package product is placed into an assets directory under the debugging base item, and an entry applet appId, a homepage and the like configured by the client side are required to be set as the applet, so that the compiled App is changed into the applet App from the debugging base.
5. And (3) small program operation:
5.1, in the development process, before entering the applet, entering a debugging base home page, wherein the page is provided by a support package in the section 3, the support package and the applet being debugged form a native ReactNative project together, and the native ReactNative project is loaded and operated in the debugging base.
5.2, in a non-development period, the small program can be compiled into native Android and iOS applications, and can also be downloaded, updated, loaded, unloaded and the like in the main application as a standard small program.
5.3, the applet can be compiled into native Android and iOS application, when the application is started, the configured parameters of the applet, such as appId and appType, are read natively, after the ReactNative initialization is completed, a file of the applet, generally index.
5.4, in the App, the applets exist in the form of zip resource packages, and can be packaged into the App in advance or downloaded after the App is started.
5.5, when the applet is opened in the App, a zip resource package is searched locally according to the applet appId, then an index.
The method for developing and loading the applet based on the ReactNative in the mobile APP is adopted, and the development method of the applet based on the ReactNative is provided, so that the applet can be developed by using the ReactNative grammar, and meanwhile, proprietary deployment and the issuing and management of the applet can be carried out without depending on three-party manufacturers. The invention also provides a small program packaging method based on the ReactNative, thereby realizing packaging of the ReactNative project into an independent small program project and realizing the problem that the native App loads the ReactNative small program.
In this specification, the invention has been described with reference to specific embodiments thereof. It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.
Claims (9)
1. A method for realizing development and loading of an applet in a mobile APP based on Reactnative is characterized by comprising the following steps:
(1) creating an applet and an internal file according to a drawing directory structure, wherein the applet and the internal file comprise an entry file, a project description file, a project code, a project dependence description file and a project packaging configuration file;
(2) debugging a base support package and reference;
(3) developing an applet;
(4) packing and running the small program compiling;
(5) and running the small program.
2. The method for realizing applet development and loading in mobile APP based on ReactNative according to claim 1, wherein the step (2) specifically comprises the following steps:
(2.1) debugging the base and the support package, and calling and installing relevant dependencies and quoting the support package;
(2.2) starting the debugging service, reading the item description file, and setting the item route as an applet entry file;
(2.3) developing page contents through a UI framework provided by the support package.
3. The method for realizing applet development and loading in mobile APP based on ReactNative according to claim 1, wherein the step (2.2) specifically comprises the following steps:
(2.2.1) judging whether the development mode is in the development mode, if so, continuing the step (2.2.2); otherwise, continuing (2.2.3);
(2.2.2) in a development mode, displaying a debugging home page provided by the support packet, displaying a list of the current debugging small program and the latest debugging small program, providing a configuration debugging IP and a port, and connecting and calling a service by a base after the configuration is finished;
and (2.2.3) in a non-development mode, loading a corresponding media file by the support packet according to the packaged configuration entry applet parameters, and jumping to a corresponding page by the support packet through route navigation according to the applet appId and the entry module name after loading.
4. The method for realizing applet development and loading in mobile APP based on ReactNative according to claim 1, wherein the step (3) specifically comprises the following steps:
(3.1) developing small programs in the debugging base, connecting debugging service after a support package configures addresses in the debugging base, and providing a compiled product resource package of all files of the project;
and (3.2) compiling in real time when the file in the item directory changes, and synchronizing to a debugging base.
5. The method for realizing applet development and loading in mobile APP based on ReactNative according to claim 4, wherein the step (3.1) specifically comprises the following steps:
(3.1.1) compiling the single file;
and (3.1.2) debugging service is carried out, and functions of file change real-time updating, page refreshing, breakpoint debugging and network data viewing are provided.
6. The method for realizing applet development and loading in mobile APP based on ReactNative according to claim 1, wherein the step (4) specifically comprises the following steps:
compiling and packing are carried out, all files under the project are scanned, the files under the project directory are compiled into corresponding modules, module codes of js files are collected to generate index.
7. The method of claim 6, wherein the module compiled in step (4) includes a page implementation code, a page unique identifier, and a page dependency module, and the content of the module compiled without the js file includes information of a resource file path, a resource name, and a resource suffix name.
8. The method for realizing applet development and loading in mobile APP according to claim 1, wherein the step (5) specifically comprises:
finding a zip resource package locally according to the applet appId, loading an index.jsbundle file in the resource package, reading an applet entrance page homepage parameter, and loading a page through a ReactNative root route to realize the loading of an applet main interface.
9. The method for realizing applet development and loading based on ReactNative in mobile APP as claimed in claim 1, wherein the internal files in step (1) include entry files, project description files, project codes, project dependency description files and project packaging configuration.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011258251.1A CN112286504A (en) | 2020-11-12 | 2020-11-12 | Method for realizing development and loading of small program based on Reactnative in mobile APP |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011258251.1A CN112286504A (en) | 2020-11-12 | 2020-11-12 | Method for realizing development and loading of small program based on Reactnative in mobile APP |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112286504A true CN112286504A (en) | 2021-01-29 |
Family
ID=74398709
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011258251.1A Pending CN112286504A (en) | 2020-11-12 | 2020-11-12 | Method for realizing development and loading of small program based on Reactnative in mobile APP |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112286504A (en) |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112861057A (en) * | 2021-02-10 | 2021-05-28 | 北京百度网讯科技有限公司 | Page rendering method, device and equipment based on small program and storage medium |
| CN113434154A (en) * | 2021-06-11 | 2021-09-24 | 青岛海尔科技有限公司 | Android application packaging method and device, storage medium and electronic device |
| CN113448611A (en) * | 2021-08-31 | 2021-09-28 | 中邮消费金融有限公司 | Method and system for quickly and thermally updating application program |
| CN113835691A (en) * | 2021-09-27 | 2021-12-24 | 工银科技有限公司 | iOS application development method, system, device, medium and program product |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR20140019623A (en) * | 2012-08-06 | 2014-02-17 | 인크로스 주식회사 | An integrated platform for authoring web applications and the authoring method thereof |
| CN106843869A (en) * | 2017-01-16 | 2017-06-13 | 百融（北京）金融信息服务股份有限公司 | A kind of front end Development Engineering system and method |
| CN111124576A (en) * | 2019-12-23 | 2020-05-08 | 焦点科技股份有限公司 | Multi-platform applet and H5 page adaptation method and system |
-
2020
- 2020-11-12 CN CN202011258251.1A patent/CN112286504A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR20140019623A (en) * | 2012-08-06 | 2014-02-17 | 인크로스 주식회사 | An integrated platform for authoring web applications and the authoring method thereof |
| CN106843869A (en) * | 2017-01-16 | 2017-06-13 | 百融（北京）金融信息服务股份有限公司 | A kind of front end Development Engineering system and method |
| CN111124576A (en) * | 2019-12-23 | 2020-05-08 | 焦点科技股份有限公司 | Multi-platform applet and H5 page adaptation method and system |
Cited By (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112861057A (en) * | 2021-02-10 | 2021-05-28 | 北京百度网讯科技有限公司 | Page rendering method, device and equipment based on small program and storage medium |
| CN112861057B (en) * | 2021-02-10 | 2024-03-01 | 北京百度网讯科技有限公司 | Page rendering method, device, equipment and storage medium based on applet |
| CN113434154A (en) * | 2021-06-11 | 2021-09-24 | 青岛海尔科技有限公司 | Android application packaging method and device, storage medium and electronic device |
| CN113434154B (en) * | 2021-06-11 | 2023-07-21 | 青岛海尔科技有限公司 | Android application program packaging method and device, storage medium and electronic device |
| CN113448611A (en) * | 2021-08-31 | 2021-09-28 | 中邮消费金融有限公司 | Method and system for quickly and thermally updating application program |
| CN113835691A (en) * | 2021-09-27 | 2021-12-24 | 工银科技有限公司 | iOS application development method, system, device, medium and program product |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112286504A (en) | Method for realizing development and loading of small program based on Reactnative in mobile APP | |
| EP3605324A1 (en) | Application development method and tool, device, and storage medium thereof | |
| US11429365B2 (en) | Systems and methods for automated retrofitting of customized code objects | |
| KR101416089B1 (en) | An integrated platform for authoring web applications and the authoring method thereof | |
| US10209968B2 (en) | Application compiling | |
| CN110806868B (en) | Single-page building and loading method | |
| KR101416104B1 (en) | A dynamic loading apparatus and method of java script code performing native functions of hybrid web applications | |
| CN114077423A (en) | Airport APP development container architecture based on mobile cross-platform | |
| Verma | Mobile Test Automation With Appium | |
| KR101416096B1 (en) | A highly compatible plug-in system for developing hybrid web applications | |
| CN113835691A (en) | iOS application development method, system, device, medium and program product | |
| Uluca | Angular 6 for Enterprise-Ready Web Applications: Deliver production-ready and cloud-scale Angular web apps | |
| Bretet | Spring mvc cookbook | |
| Bilgin | Mobile Development with. NET: Build cross-platform mobile applications with Xamarin. Forms 5 and ASP. NET Core 5 | |
| Dutson | Android Development Patterns: Best Practices for Professional Developers | |
| Jaber et al. | A high-level modeling language for the efficient design, implementation, and testing of Android applications | |
| CN115080098A (en) | JavaScript-based Flutter hot updating method, device, equipment and medium | |
| CN115964019A (en) | Information fusion component specification method and system suitable for industrial scene | |
| Derks | React projects: build 12 real-world applications from scratch using react, react native, and react 360 | |
| Nagesh et al. | Cross-platform mobile application development | |
| Bilgin | Hands-on Mobile Development with. NET Core: Build Cross-platform Mobile Applications with Xamarin, Visual Studio 2019, and. NET Core 3 | |
| Iglesias | Hands-On Microservices with Kotlin: Build reactive and cloud-native microservices with Kotlin using Spring 5 and Spring Boot 2.0 | |
| Murray et al. | ng-book | |
| US11809861B2 (en) | Development environment organizer with enhanced state switching and sharing | |
| Himschoot et al. | Introduction to WebAssembly and Blazor |
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 |