Generate hybrid enterprise mobile applications in cloud environment, according to one embodiment. A web application is selected in a web integrated development environment (IDE) executing in a browser. The web application may depend on various components and the dependent build components may reside on different repositories. dependency analysis engine determines the dependent build components corresponding to the web application. The component retrieval engine retrieves the dependent build components from corresponding repositories to memory or cache of the browser where the web IDE is executing. Component build engine builds the dependent build components to a build result. Packaging engine packages the build result to a single package as an application asset package. The application asset package is received in a platform dependent build service. The application asset package is built as a hybrid mobile application in the platform dependent build service. The hybrid mobile application is published in an application store.
|
7. A computer-implemented method for generation of hybrid enterprise mobile applications in a cloud environment, the method comprising:
receiving selection of a web application in a web based integrated development environment executing in a browser;
analyzing configuration files in the web application by a dependency analysis engine to determine dependent build components;
determining nested dependencies by recursively analyzing dependencies of the dependent build components;
when the dependency analysis engine completes the analysis, retrieving the dependent build components from corresponding repositories to a volatile memory associated with the browser in a server system;
in the server system:
building the dependent build components to a build result;
packaging the build result to an application asset package;
receiving the application asset package at a platform dependent build service;
building the application asset package as a hybrid mobile application, wherein the hybrid mobile application can be executed in online mode and in offline mode; and
publishing the hybrid mobile application in an application store.
1. A non-transitory computer-readable medium to store instructions, which when executed by a computer, cause the computer to perform operations comprising:
receive instructions to select a web application in a web based integrated development environment executing in a browser;
analyze configuration files in the web application by a dependency analysis engine to determine dependent build components;
determine nested dependencies by recursively analyzing dependencies of the dependent build components;
when the dependency analysis engine completes the analysis, retrieve the dependent build components from corresponding repositories to a volatile memory associated with the browser in a server system;
in the server system:
build the dependent build components to a build result;
package the build result to an application asset package;
receive the application asset package at a platform dependent build service;
build the application asset package as a hybrid mobile application, wherein the hybrid mobile application can be executed in online mode and in offline mode; and
publish the hybrid mobile application in an application store.
13. A computer system for generation of hybrid enterprise mobile applications in a cloud environment, comprising:
a computer memory to store program code; and
a processor to execute the program code to:
receive selection of a web application in a web based integrated development environment executing in a browser;
analyze configuration files in the web application by a dependency analysis engine to determine dependent build components;
determine nested dependencies by recursively analyzing dependencies of the dependent build components;
when the dependency analysis engine completes the analysis, retrieve the dependent build components from corresponding repositories to a volatile memory associated with the browser in a server system;
in the server system:
build the dependent build components to a build result;
package the build result to an application asset package;
receive the application asset package at a platform dependent build service;
build the application asset package as a hybrid mobile application, wherein the hybrid mobile application can be executed in online mode and in offline mode; and
publish the hybrid mobile application in an application store.
18. A cloud environment for generation of a hybrid enterprise mobile application, the cloud environment comprising:
a cloud server executing a web based integrated development environment to:
receive selection of a web application in the web based integrated development environment;
analyze configuration files in the web application by a dependency analysis engine to determine dependent build components;
determine nested dependencies by recursively analyzing dependencies of the dependent build components;
when the dependency analysis engine completes the analysis, retrieve the dependent build components from corresponding repositories to a volatile memory associated with the browser;
build the dependent build components to a build result;
package the build result to an application asset package;
receive the application asset package at a platform dependent build service;
build the application asset package as the hybrid enterprise mobile application, wherein the hybrid mobile application can be executed in online mode and in offline mode; and
publish the hybrid enterprise mobile application in an application store; and
a cloud client accessing the cloud environment to:
download the hybrid enterprise mobile application in the cloud client.
2. The computer-readable medium of
3. The computer-readable medium of
generate a root page of the web application with bootstrap and script configuration.
4. The computer-readable medium of
construct the application asset package based on the configuration files in the web application; and
compress the application asset package.
5. The computer-readable medium of
acquire assets corresponding to the dependent build components; and
save the retrieved dependent build components in a memory of the browser.
6. A computer-readable medium of
access the published hybrid mobile application from the application store in a first mobile device.
8. The method of
packaging the application asset package into a single file including the dependent build components.
9. The method of
generating a root page of the web application with bootstrap and script configuration.
10. The method of
constructing the application asset package based on the configuration files in the web application; and
compressing the application asset package.
11. The method of
acquiring assets corresponding to the dependent build components; and
saving the retrieved dependent build components in a memory of the browser.
12. The method of
receiving the application asset package in a platform dependent build service;
building the application asset package as a hybrid mobile application; and
publishing the hybrid mobile application in an application store.
14. The system of
15. The system of
generate a root page of the web application with bootstrap and script configuration.
16. The system of
construct the application asset package based on the configuration files in the web application; and
compress the application asset package.
17. The system of
acquire assets corresponding to the dependent build components; and
save the retrieved dependent build components in a memory of the browser.
|
|||||||||||||||||||||||||
Illustrated embodiments generally relate to data processing, and more particularly to a system to generate hybrid enterprise mobile applications in cloud environment.
Enterprises provide development tools that enable developers with end-to-end development process. Browser based development tools enable designing and development of enterprise applications through simplified user interfaces. During development of applications, developers work on, for example generate, build and execute the application. The steps of developing, generating build and executing application are iterative by nature. In the iterative development process it is a challenge to identify the dependencies of the application. Further, in the development environment, changes to the application are dynamic. Therefore, it is challenging to dynamically identify the dependencies to the dynamic application in an iterative development environment.
The claims set forth the embodiments with particularity. The embodiments are illustrated by way of examples and not by way of limitation in the figures of the accompanying drawings in which like references indicate similar elements. Various embodiments, together with their advantages, may be best understood from the following detailed description taken in conjunction with the accompanying drawings.
Embodiments of techniques for generation of hybrid enterprise mobile applications in cloud environment are described herein. In the following description, numerous specific details are set forth to provide a thorough understanding of the embodiments. A person of ordinary skill in the relevant art will recognize, however, that the embodiments can be practiced without one or more of the specific details, or with other methods, components, materials, etc. In some instances, well-known structures, materials, or operations are not shown or described in detail.
Reference throughout this specification to “one embodiment”, “this embodiment” and similar phrases, means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one of the one or more embodiments. Thus, the appearances of these phrases in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.
In one embodiment, when a web application is selected, dependency analysis engine 104, component retrieval engine 106, component build engine 108 and packaging engine 110 are executed in a sequence in the web IDE 102. The dependency analysis engine 104 analyzes configuration files in the web application. The web application may depend on various components and the dependent build components may reside on different locations or repositories. The dependency analysis engine 104 analyzes configuration files to identify dependent build components required by the web application, and also identifies locations where the components are available. The dependent build components required by the web application are dependent build component A 112, dependent build component B 114, and dependent build component C 116. The components required by the enterprise mobile application are generated as a list of dependent build components. The list of dependent build components is sent to the component retrieval engine 106 for processing.
The component retrieval engine 106 retrieves the dependent build components from corresponding repositories to memory or cache of the browser where web IDE 102 is executing. The memory or cache of the browser, caches or stores the retrieved dependent build components. Volatile memory such as random access memory can be used to cache data in the browser. Size allocated in the random access memory determines the capacity and speed of caching the retrieved components. Component build engine 108 fetches the dependent build components retrieved to the memory of the browser, and builds the components to a build result. Build process may include compilation, reducing file size, etc., of the dependent build components for better performance. Packaging engine 110 packages the build result into an application asset package 118. The application asset package 118 is a single file including all the dependent build components for the web application. From the web IDE 102 the application asset package 118 is sent to platform dependent build service 120 to build a platform specific build result. The application asset package 118 is built as a hybrid mobile application in the platform dependent build service 120. The hybrid mobile application is published in an application store. The hybrid mobile application published in the application store can be distributed to a variety of computing handheld devices such as mobile phones, personal digital assistants, smart watches, etc., and other computing devices such as desktop computers, etc. The computing handheld devices and other computing devices may also be referred to as cloud clients. The hybrid mobile application can be executed on various mobile platforms. The hybrid mobile application can be executed on any mobile device in an online mode and as well as in an offline mode. The hybrid mobile application may be used in the iterative development process for further development. For example, in an ongoing iterative development effort where software code changes are performed in the web application iteratively, the dependencies are identified and automatically packaged as the hybrid mobile application.
It should be appreciated that the dependency analysis engine 104, component retrieval engine 106, component build engine 108 and packaging engine are not limited to the examples explained below, various other implementations may also be performed. The dependency analysis engine 104, component retrieval engine 106, component build engine 108 and packaging engine may be executed in various orders or not in sequence depending on the implementation in the web IDE 102. Implementation of the engines may include a combination of software program logic and hardware components enabling various functionalities of the engines as explained below. In one embodiment, web IDE 102 with engine functionalities can be deployed in a server system/cloud server accessing in-memory database where data is stored in a volatile memory such as a random access memory (RAM). In one embodiment, the dependency analysis engine 104, the component retrieval engine 106, the component build engine 108 and the packaging engine 110 in the web IDE may be executed in a first system. The platform dependent build service 120 used to build a platform specific build result may be executed in a second system. The application store may be available in a third system. It should be appreciated that the first system, second system and third system am merely indicative numerals and may be combined in one or more systems depending on the nature of implementation.
Dependency acquiring component 218 is used to acquire the assets of the identified dependent build components from the identified source repositories. The acquired assets are transmitted to the memory of the browser. File format adaptation component 220 enables adaptation of file format of the acquired assets during the transmission. Dependency metadata component 222 is used to analyze the acquired assets of the dependent build components, and generate metadata that is required by component build engine 208. In the component build engine 208, hybrid mobile project build component 224 generates a root page of the enterprise mobile application (i.e. index.html) with bootstrap, script configuration files, script loading sequence, etc. Configuration adaptation component 226 helps to adapt the configuration of scripts and style sheets of components according to the requirements of configuration files of the enterprise mobile application, and the dependent build components. For example, style sheets in basic format are compiled into cascading style sheets (CSS) format as required by a library in the dependent build components. Minification component 228 in the component build engine 208 removes unnecessary characters or minifies files to reduce the file size. For example, script files in the dependent build components are minified from plain text to minification format. Asset construction component 230 in package engine 210 integrates and constructs the asset package file structure according to the enterprise mobile application and configurations of the dependent build components. Package generation component 232 archives and compresses the constructed asset package file to a format required for transmission to platform build services. Release and debug support component 234 adapts the compressed asset package based on the debug or release package specification indicated.
The list of components such as: dependent build component A on repository A, dependent build component B on repository X, dependent build component C in web IDE, etc., are sent to a component retrieval engine for processing. The component retrieval engine retrieves the list of components from the corresponding repositories. Dependent build component A is retrieved from repository A, dependent build component B is retrieved from repository X, dependent build component C is retrieved from web IDE. The retrieved components are saved in the memory of the web browser running the web IDE. Component build engine fetches the components saved in the memory of the web browser to generate a build result. The build process includes compilation of style sheets, script minification, etc. The script minification reduces the file size of the build result and to improve the performance. The build result is sent to packaging engine. The packaging engine packages the build result into an application asset package.
Some embodiments may include the above-described methods being written as one or more software components. These components, and the functionality associated with each, may be used by client, server, distributed, or peer computer systems. These components may be written in a computer language corresponding to one or more programming languages such as, functional, declarative, procedural, object-oriented, lower level languages and the like. They may be linked to other components via various application programming interfaces and then compiled into one complete application for a server or a client. Alternatively, the components maybe implemented in server and client applications. Further, these components may be linked together via various distributed programming protocols. Some example embodiments may include remote procedure calls being used to implement one or more of these components across a distributed programming environment. For example, a logic level may reside on a first computer system that is remotely located from a second computer system containing an interface level (e.g., a graphical user interface). These first and second computer systems can be configured in a server-client, peer-to-peer, or some other configuration. The clients can vary in complexity from mobile and handheld devices, to thin clients and on to thick clients or even other servers.
The above-illustrated software components are tangibly stored on a computer readable storage medium as instructions. The term “computer readable storage medium” should be taken to include a single medium or multiple media that stores one or more sets of instructions. The term “computer readable storage medium” should be taken to include any physical article that is capable of undergoing a set of physical changes to physically store, encode, or otherwise carry a set of instructions for execution by a computer system which causes the computer system to perform any of the methods or process steps described, represented, or illustrated herein. Examples of computer readable storage media include, but are not limited to: magnetic media, such as hard disks, floppy disks, and magnetic tape; optical media such as CD-ROMs, DVDs and holographic devices; magneto-optical media; and hardware devices that are specially configured to store and execute, such as application-specific integrated circuits (ASICs), programmable logic devices (PLDs) and ROM and RAM devices. Examples of computer readable instructions include machine code, such as produced by a compiler, and files containing higher-level code that are executed by a computer using an interpreter. For example, an embodiment may be implemented using Java. C++, or other object-oriented programming language and development tools. Another embodiment may be implemented in hard-wired circuitry in place of, or in combination with machine readable software instructions.
A data source is an information resource. Data sources include sources of data that enable data storage and retrieval. Data sources may include databases, such as, relational, transactional, hierarchical, multi-dimensional (e.g., OLAP), object oriented databases, and the like. Further data sources include tabular data (e.g., spreadsheets, delimited text files), data tagged with a markup language (e.g., XML data), transactional data, unstructured data (e.g., text files, screen scrapings), hierarchical data (e.g., data in a file system, XML data), files, a plurality of reports, and any other data source accessible through an established protocol, such as, Open Data Base Connectivity (ODBC), produced by an underlying software system (e.g., ERP system), and the like. Data sources may also include a data source where the data is not tangibly stored or otherwise ephemeral such as data streams, broadcast data, and the like. These data sources can include associated data foundations, semantic layers, management systems, security systems and so on.
In the above description, numerous specific details are set forth to provide a thorough understanding of embodiments. One skilled in the relevant art will recognize, however that the embodiments can be practiced without one or more of the specific details or with other methods, components, techniques, etc. In other instances, well-known operations or structures are not shown or described in detail.
Although the processes illustrated and described herein include series of steps, it will be appreciated that the different embodiments are not limited by the illustrated ordering of steps, as some steps may occur in different orders, some concurrently with other steps apart from that shown and described herein. In addition, not all illustrated steps may be required to implement a methodology in accordance with the one or more embodiments. Moreover, it will be appreciated that the processes may be implemented in association with the apparatus and systems illustrated and described herein as well as in association with other systems not illustrated.
The above descriptions and illustrations of embodiments, including what is described in the Abstract, is not intended to be exhaustive or to limit the one or more embodiments to the precise forms disclosed. While specific embodiments of, and examples for, the one or more embodiments are described herein for illustrative purposes, various equivalent modifications are possible within the scope, as those skilled in the relevant art will recognize. These modifications can be made in light of the above detailed description. Rather, the scope is to be determined by the following claims, which are to be interpreted in accordance with established doctrines of claim construction.
Cao, Lin, Wang, Qiu Shi, Zhou, Yi Quan
| Patent | Priority | Assignee | Title |
| 10838744, | Dec 04 2018 | SAP SE | Web component design and integration system |
| 11232172, | Dec 04 2018 | SAP SE | Collaborative web application and data system |
| 11886891, | Sep 10 2021 | SAP SE | Context-based multiexperience element dynamically generated using natural language processing |
| 11972235, | Mar 02 2022 | SAP SE | No-code metadata-driven provisioning of workflow task user interfaces |
| 12106086, | Oct 13 2022 | SAP SE | Check dependency and setup with metaprogramming for low-code and no-code development |
| ER2245, |
| Patent | Priority | Assignee | Title |
| 7596620, | Nov 04 2008 | APPCELERATOR, INC | System and method for developing, deploying, managing and monitoring a web application in a single environment |
| 7694277, | May 14 2003 | Microsoft Technology Licensing, LLC | Cross version customization of design environment |
| 7950010, | Jan 21 2005 | SAP SE | Software deployment system |
| 8793584, | May 24 2006 | International Business Machines Corporation | Customizable user interface wrappers for web applications |
| 9069375, | Apr 30 2013 | JYBE TECHNOLOGY, LLC | Method and system for platform-independent application development |
| 9471303, | Feb 04 2015 | SAP SE | Façade framework for IDE |
| 9672032, | Feb 04 2015 | SAP SE | Mobile enabled application |
| 20060212864, | |||
| 20070006217, | |||
| 20070011650, | |||
| 20070101197, | |||
| 20080127171, | |||
| 20080147671, | |||
| 20110185339, | |||
| 20110225488, | |||
| 20110265077, | |||
| 20110283194, | |||
| 20120096433, | |||
| 20130067459, | |||
| 20130219415, | |||
| 20130275623, | |||
| 20130311984, | |||
| 20140047517, | |||
| 20140053126, | |||
| 20140109115, | |||
| 20140201328, | |||
| 20140282395, | |||
| 20140297713, | |||
| 20150067641, | |||
| 20150082298, | |||
| 20150089475, | |||
| 20150113504, | |||
| 20150347119, | |||
| 20160048388, | |||
| 20160154629, | |||
| 20160156700, | |||
| 20160164994, | |||
| 20160164999, | |||
| 20160224335, | |||
| 20160253171, |
| Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
| Feb 22 2016 | ZHOU, YI QUAN | SAP SE | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 039070 | /0136 | |
| Feb 22 2016 | WANG, QIU SHI | SAP SE | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 039070 | /0136 | |
| Feb 22 2016 | CAO, LIN | SAP SE | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 039070 | /0136 | |
| Feb 23 2016 | SAP SE | (assignment on the face of the patent) | / |
| Date | Maintenance Fee Events |
| Oct 13 2021 | M1551: Payment of Maintenance Fee, 4th Year, Large Entity. |
| Date | Maintenance Schedule |
| Apr 24 2021 | 4 years fee payment window open |
| Oct 24 2021 | 6 months grace period start (w surcharge) |
| Apr 24 2022 | patent expiry (for year 4) |
| Apr 24 2024 | 2 years to revive unintentionally abandoned end. (for year 4) |
| Apr 24 2025 | 8 years fee payment window open |
| Oct 24 2025 | 6 months grace period start (w surcharge) |
| Apr 24 2026 | patent expiry (for year 8) |
| Apr 24 2028 | 2 years to revive unintentionally abandoned end. (for year 8) |
| Apr 24 2029 | 12 years fee payment window open |
| Oct 24 2029 | 6 months grace period start (w surcharge) |
| Apr 24 2030 | patent expiry (for year 12) |
| Apr 24 2032 | 2 years to revive unintentionally abandoned end. (for year 12) |