This disclosure provides various embodiments for providing ui services. An application-independent, reusable ui framework receives a request from a first application, to perform a first operation on a first set of data relating to presentation of the first set of data on a ui. A subset of the first set of data is received from a data provider independent of the ui framework. At least one first service is identified in response, the first service hosted by the ui framework and adapted to perform the first operation on the first set of data. The first operation is performed on the subset of the first set of data using the at least one identified first service to produce a first processed set of data adapted for presentation on a ui of the first application. The first processed set of data is sent to the first application.
|
1. A computer-implemented method comprising:
receiving a request, at an application-independent, reusable user interface (ui) framework, from a first application, to perform at least one first operation on a first set of data relating to presentation of the first set of data on a ui associated with the first application, wherein the received request is for performance of a plurality of operations, including the at least one first operation, and a plurality of services hosted by the ui framework are identified in response to the received request, each service in the plurality of services adapted to perform at least one of the plurality of operations;
receiving, from a data provider, independent of the ui framework, a subset of the first set of data corresponding to the received request;
identifying, in response to the received request, at least one first service, hosted by the ui framework, adapted to perform the at least one first operation on the first set of data;
identifying a particular order for the performance of the plurality of operations;
initiating performance of each of the plurality of operations by a corresponding one of the plurality of services according to the identified particular order, wherein the at least one first operation is performed on the subset of the first set of data using the identified at least one first service to produce a first processed set of data; and
sending the first processed set of data to the first application, the first processed set of data adapted for presentation on the ui associated with the first application.
24. A computer-program product for providing an application-independent, reusable, and shared user interface (ui) framework, the computer-program product comprising computer-readable instructions embodied on tangible, non-transitory media and operable when executed to:
receive a request from a first application, to perform at least one first operation on a first set of data relating to presentation of the first set of data on a user-interface associated with the first application, wherein the received request is for performance of a plurality of operations, including the at least one first operation, and a plurality of services hosted by the ui framework are identified in response to the received request, each service in the plurality of services adapted to perform at least one of the plurality of operations;
receive, from a data provider, independent of the ui framework, a subset of the first set of data corresponding to the received request;
identify, in response to the request, at least one service, hosted by the ui framework, adapted to perform the at least one first operation on the first set of data;
identify a particular order for the performance of the plurality of operations;
initiate performance of each of the plurality of operations by a corresponding one of the plurality of services according to the identified particular order, wherein the at least one first operation is performed on the subset of the first set of data using the at least one identified service to produce a first processed set of data; and
send the first processed set of data to the first application, the first processed set of data adapted for presentation on the ui associated with the first application.
20. A computer-implemented method comprising:
receiving a user request through a user interface (ui) presented on a computing device, to perform at least one operation on particular table data, the at least one operation relating to presentation of at least a portion of the particular table data on the user-interface, wherein the received user request is for performance of a plurality of operations, including the at least one operation, and a plurality of services hosted by an application-independent, reusable, shared, ui framework are identified in response to the received user request, each service in the plurality of services adapted to perform at least one of the plurality of operations;
identifying a particular order for the performance of the plurality of operations;
initiating performance of each of the plurality of operations by a corresponding one of the plurality of services according to the identified particular order, wherein a request to perform the at least one operation is sent to the shared ui framework, and wherein the sent request includes an identification of the particular table data and the at least one operation, wherein the particular table data is stored in a memory of a data source independent of the shared ui framework;
receiving a response from the shared ui framework including processed table data, wherein the processed table data includes at least a subset of the particular table data, the subset of the particular table data modified in accordance with performance of the at least one operation on the subset of the particular table data by one or more services hosted by the shared ui framework; and
displaying at least a portion of the processed table data on the ui.
25. A computer-program product comprising computer-readable instructions embodied on tangible, non-transitory media and operable when executed to:
receive a user request through a user interface (ui) presented on a computing device, to perform at least one operation on particular table data, the at least one operation relating to presentation of at least a portion of the particular table data on the user-interface, wherein the user request is for performance of a plurality of operations, including the at least one operation, and a plurality of services hosted by an application-independent, reusable, shared, ui framework are identified in response to the user request, each service in the plurality of services adapted to perform at least one of the plurality of operations;
identifying a particular order for the performance of the plurality of operations;
initiating performance of each of the plurality of operations by a corresponding one of the plurality of services according to the identified particular order, wherein a request to perform the at least one operation is sent to the shared ui framework, and wherein the request includes an identification of the particular table data and the at least one operation, wherein the particular table data is stored in a memory of a data source independent of the shared ui framework;
receive a response from the shared ui framework including processed table data, wherein the processed table data includes at least a subset of the particular table data, the subset of the particular table data modified in accordance with performance of the at least one operation on the subset of the particular table data by one or more services hosted by the shared ui framework; and
display at least a portion of the processed table data on the ui.
2. The computer-implemented method of
3. The computer-implemented method of
4. The computer-implemented method of
5. The computer-implemented method of
6. The computer-implemented method of
identifying a minimum subset of the first set of data that, when processed by the at least one first operation, produces a processed set of data responsive to the received request; and
sending, to the data provider, a request for the minimum subset of the first set of data, wherein the data received from the data provider comprises the minimum subset of the first set of data.
7. The computer-implemented method of
receiving a second request, at the ui framework, from a second application, to perform at least one second operation on a second set of data relating to presentation of the second set of data on a ui associated with the second application;
receiving, from a second data provider independent of the ui framework, a subset of the second set of data corresponding to the second request;
identifying, in response to the second request, at least one second service, hosted by the ui framework, adapted to perform the at least one second operation on the second set of data;
performing the at least one second operation on the subset of the second set of data using the at least one second service to produce a second processed set of data; and
sending the second processed set of data to the second application, the second processed set of data adapted for presentation on the ui associated with the second application.
8. The computer-implemented method of
9. The computer-implemented method of
identifying that the data provider is capable of performing at least a second operation;
sending a request to the data provider to perform at least the second operation;
wherein:
the request received at ui framework is for performance of at least two operations, including the first operation and the second operation;
the data provider has performed the at least the second operation on the first set of data prior to receiving the first set of data from the data provider; and
the identified at least one first service is used to perform at least the first operation on the subset of the received first set of data.
10. The computer-implemented method of
11. The computer-implemented method of
receiving a request to modify a first service configuration model associated with the first service;
modifying the first service configuration model based at least in part on the received request to modify the first service configuration model; and
wherein performance of the first operation is based at least in part on the modified first service configuration model.
12. The computer-implemented method of
13. The computer-implemented method of
14. The computer-implemented method of
15. The computer-implemented method of
16. The computer-implemented method of
17. The computer-implemented method of
18. The computer-implemented method of
19. The computer-implemented method of
21. The computer-implemented method of
22. The computer-implemented method of
23. The computer-implemented method of
|
This present disclosure relates to user interface operations, and, more particularly, to systems, software, and computer-implemented methods for providing user interface functionality through a shared user interface framework.
User interface elements can be displayed by a graphical user interface of a computing device and interacted with by users of the device. It is common, in modern software applications for the application to have, associated with it, at least one such user interface element or “UI.” Users can interact with a program's UI affecting a change in the UI displayed to the user. One example of a UI are table UIs adapted to allow users to interact with table data through common table UI operations such as sorting, filtering, grouping, expanding, and performing analytical calculations on data displayed in the table UI.
Modern software application developers have a myriad of UI technologies to choose from when designing and building an application and its corresponding UI, and the available selection of UI technologies continues to expand. UI technologies include Adobe Flash, JavaScript+html, XUL, SwixML, Thinlet, Buoy, Swing, IBM's AWT, and others. As new UI technologies are developed, they sometimes replace older UI technologies, prompting application developers to redesign software systems to incorporate the latest UI technology.
Advances in software development, distributed software environments and Service Oriented Architectures (SOA) have led to many advancements in service-based software architectures. SOA is an architectural style for building software applications that use services exposed to applications over a network. The internet has allowed implementations of web-based SOA environments, or web services that deliver services over the web using technologies such as XML, WSDL, SOAP, and UDDI. SOA generally promotes reusability of software resource and loose coupling between software components. Applications in SOA are built based on services. A service is an implementation of a well-defined business functionality, and such services can then be consumed by clients in different applications or business processes. One example is SAP's Business Intelligence Consumer Services™ product which can expose services for use in connection with other applications such as SAP's Business Explorer™.
This disclosure provides various embodiments for providing UI services on behalf of a software application. An application-independent, reusable UI framework receives a request from a first application, to perform at least one first operation on a first set of data relating to presentation of the first set of data on a user interface associated with the first application. A subset of the first set of data, corresponding to the request, is received from a data provider independent of the UI framework. At least one first service is identified, in response to the request, the first service hosted by the UI framework and adapted to perform the at least one first operation on the first set of data. The first operation is performed on the subset of the first set of data using the at least one identified first service to produce a first processed set of data adapted for presentation on the user interface of the first application. The first processed set of data is sent to the first application.
While generally described as computer implemented software that processes and transforms the respective data, some or all of the aspects may be computer implemented methods or further included in respective systems or other devices for performing this described functionality. The details of these and other aspects and embodiments of the present disclosure are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the disclosure will be apparent from the description and drawings, and from the claims.
Like reference symbols in the various drawings indicate like elements.
This disclosure generally describes software, computer-implemented methods, and systems relating to a reusable, software-architecture-independent user interface (UI) framework that can be integrated into an application's architecture stack to provide shared functionality for the configuration and execution of user-interface-related operations on the application. For instance, the UI framework can encapsulate and provide a shared, central set of commonly used table operations (e.g., filtering, sorting, grouping, expanding/hiding rows, columns, and cells, etc.) and services that can be reused in the architecture stacks of distinct and varied applications, including applications using different UI formatting protocols, designs, and technologies. Rather than forcing a developer to building these common functionalities into an application's UI each time a new application or new version is developed, a shared UI framework can simplify development of an application UI by allowing the developer to access UI services exposed through the shared UI framework and integrate the services' functionality into the developer's own UI design. Moreover, because the shared UI framework is largely application- and UI-technology-independent, developers can easily migrate to new or different UI technologies without having to redevelop the UI operation functionality provided through the UI framework.
Distributed software environments, including SOA systems, enterprise software systems, and cloud-based software systems can also make use of a shared UI framework. Indeed, in some instances, several distinct software applications in a distributed computing environment may seek to access, edit, or otherwise use data from one or more data sources, including data sources external to the applications, such as a centralized database. A UI framework can interface directly with the source of the data designated for display in an application's UI. The UI framework's ability to interface with a wide variety of data sources and service consumers permits the UI framework to be widely reused across a myriad of applications and data types. A developer desiring to incorporate certain UI operations within the UI architecture of the developer's project can simply subscribe to, piggy-back, interface with, or otherwise access the shared UI services provided by an application-independent UI framework to realize the desired UI functionality without having to engineer and program the functionality from scratch. A UI framework can offer built-in support for a number of UI concepts and operations commonly used by different UI interface technologies, such as table UI operations.
Turning to the example implementation of
In the present example, the UI framework server 104 and the application server 112 each include at least one interface (106 and 115, respectively), one or more processors (105 and 113, respectively), and computer-readable memory (107 and 114, respectively). In some instances, the UI framework server 104 and one or more application servers 112 can be hosted on a common computing system, server, or server pool, and share computing resources, including shared memory, processors, and interfaces. The interfaces 106, 115 are used for communicating with other systems in a client-server or other distributed environment (including within environment 100) connected to the network 128, for example the one or more clients 108, an application developer 120, or any other computing device adapted to interface with the servers 104, 112, including devices not illustrated in
Each of the example servers 104, 112 also includes a processor (105, 113 respectively). Each processor 105, 113, and 117 executes instructions and manipulates data to perform the operations of the associated server 104, 112, and may comprise, for example, a central processing unit (CPU), a blade, an application specific integrated circuit (ASIC), or a field-programmable gate array (FPGA), among other suitable options. Although each processor 105, 113 is illustrated as a single processor, multiple processors may be used according to the particular needs of the associated server. References to a single processor 105, 113 are meant to include multiple processors where applicable. The operations that each processor 105, 113 executes are determined by the purpose and operations of its associated server. Generally, the processor 105, 113 executes instructions and manipulates data to perform the operations of its respective server and, specifically, the software systems and applications (e.g., 116, 124) hosted by the server.
At a high level, each “server” (e.g., 104, 112) includes one or more electronic computing devices operable to receive, transmit, process, store, or manage data and information associated with the environment 100. Specifically, a server is responsible for receiving requests from one or more clients and sending the appropriate response the requesting client. In addition to requests from external clients, requests may also be sent from internal users, external or third-party customers, other automated applications, as well as any other appropriate entities, individuals, systems, or computers. For example, although
In the case of an application server 112, the processor 113 can execute the functionality required to receive and respond to requests from the clients 108, as well as client applications 124 interfacing with the server's hosted application 116. Regardless of the particular implementation, “software” may include computer-readable instructions, firmware, wired or programmed hardware, or any combination thereof on a tangible medium operable when executed to perform at least the processes and operations described herein. Indeed, each software component may be fully or partially written or described in any appropriate computer language including C, C++, Java, Visual Basic, assembler, Perl, any suitable version of 4GL, as well as others. Applications can be implemented as individual modules that implement the various features and functionality through various objects, methods, or other processes, or may instead include a number of sub-modules, third party services, components, libraries, and such, as appropriate. Conversely, the features and functionality of various components can be combined into single components as appropriate.
At a high level, each of the one or more hosted applications (e.g., 109, 116, 124) illustrated in the environment 100 can include any application, program, module, process, or other software that may execute, change, delete, generate, or otherwise manage information according to the present disclosure, particularly in response to and in connection with one or more requests received from the illustrated clients 108, as well as other applications. In certain cases, only one hosted application may be located at a particular server. In others, a plurality of related and/or unrelated hosted applications may be stored at a single server, or located across a plurality of other servers, as well. In certain cases, environment 100 may implement a composite hosted application. For example, portions of the composite application may be implemented as Enterprise Java Beans (EJBs) or design-time components may have the ability to generate run-time implementations into different platforms, such as J2EE (Java 2 Platform, Enterprise Edition), ABAP (Advanced Business Application Programming) objects, or Microsoft's .NET, among others. Additionally, the applications 116, 124 may represent web-based applications accessed and executed by remote clients 108 or client applications 124 via the network 128 (e.g., through the Internet). Further, while illustrated as internal to server 112, one or more processes associated with a particular hosted application 116 may be stored, referenced, or executed remotely. For example, a portion of a particular hosted application 116 may be a web service associated with the application that is remotely called, while another portion of the hosted application 116 may be an interface object or agent bundled for processing at a remote client 108. Moreover, any or all of the hosted applications 116 may be a child or sub-module of another software module or enterprise application (not illustrated) without departing from the scope of this disclosure. Still further, portions of the hosted application 116 may be executed by a user working directly at server 112, as well as remotely at client 108.
Similarly, the UI framework server 104 can include one or more processors 105 executing software comprising the UI framework 132. The processor 105 executes instructions and manipulates data to perform UI framework operations and tasks (described below) as well as serve UI services to a plurality of UI service consumers, including applications (e.g., 109, 116, 124), systems, and programs remote from the UI framework server 104. The UI framework server 104 can be adapted to serve the UI framework to consumers in a variety of contexts including local, private, distributed, enterprise, and cloud-computing software system environments. The UI framework server 104 can be implemented using a single processor 105 or multiple processors, including multiple processors operating in a parallel processing computing environment.
Each of the example servers 104, 112, and 116 also includes a memory (107 and 114, respectively). Each memory may include any memory or database module and may take the form of volatile or non-volatile memory including, without limitation, non-transitory memory elements, magnetic media, optical media, random access memory (RAM), read-only memory (ROM), removable media, or any other suitable local or remote memory component. Each memory may store various objects or data, including classes, frameworks, applications, backup data, business objects, jobs, web pages, web page templates, database tables, content repositories storing business or other dynamic information, or other information including any parameters, variables, algorithms, instructions, rules, constraints, or references thereto relevant to the purposes of the particular server. Each memory may also include any other appropriate data, such as VPN applications, firmware logs and policies, firewall policies, a security or access log, print or other reporting files, as well as others. Again, the particular data and instructions stored in each memory 107, 114 will be described in detail below in connection with the illustrated implementations of the software environment 100 and components thereof.
Generally, the network 128 facilitates wireless or wireline communications between the components of the software environment 100 (i.e., between the UI framework server 104 and one or more application servers 112, an application developer 12, and clients 108, as well as between the other components as appropriate), as well as with any other local or remote computer, such as those associated with the one or more applications 124 or external data sources 144. The network 128 can be implemented as one or more distinct networks. In any implementation, the network 128 may be a continuous or discontinuous network without departing from the scope of this disclosure, so long as at least a portion of the network 128 may facilitate communications between senders and recipients. The network 128 may be all or a portion of an enterprise or secured network. As an example, in
The illustrated implementation of
The GUI 110 comprises a graphical user interface operable to allow the user to interface with at least a portion of environment 100 for any suitable purpose, including allowing a user to interact with one or more software applications (e.g., 109, 116, 124). Generally, the GUI 110 provides users with an efficient and user-friendly presentation of data provided by or communicated within the system. The term “graphical user interface,” or GUI, may be used in the singular or in the plural to describe one or more graphical user interfaces and each of the displays of a particular graphical user interface. Therefore, the GUI 110 can be any graphical user interface, such as a web browser, touch screen, or command line interface (CLI) that processes information in the environment 100 and efficiently presents the results to the user. In general, the GUI 110 may include a plurality of user interface (UI) elements such as interactive fields, pull-down lists, media players, tables, graphics, virtual machine interfaces, buttons, etc. operable by the user at the client 108. These UI elements may be related to the functions of one or more applications (e.g., 116, 124), including applications 109 hosted at the client.
While
Turning now to
The service controller 205 can be adapted to manage and guarantee the consistent configuration and execution of the individual UI services 225 provided by the UI framework 200. Additionally, in some instances, the service controller can provide interfaces to, or be the interface to, one or more external components utilizing services provided by the UI interface or external components contributing towards the operation of the UI framework 200. Services can be exposed to external components via one or more APIs. Examples of external components can include service data consumers 210, data sources 220, and service behavior requests 215. In general, the service controller 205 can receive requests 250 from a service consumer 210 to perform certain operations on data to be displayed on a UI associated with the service consumer 210. The service controller 205 identifies a data source 200, corresponding to the request 250, to which one or more UI operations are to apply. The service controller 205 identifies and retrieves the particular data 255 needed for fulfilling the consumer's UI operation and request. The service controller 205 can further interpret the request 250 to identify one or more services 225 providing functionality needed to perform the operation and complete the request 250 on the identified data 255. Each UI service 225 corresponds to and performs at least one operation on data for use in display by a UI associated with the service consumer 210. Examples of UI services 225 include sorting, filtering, grouping, aggregation, concatenation, analytical functions, math functions, data expansion, hiding, exporting data to external applications or file formats, and format conversion.
The execution of some services 225 can change the order of table rows and columns, compared to the order of the original data stored and/or managed by its data source 220. Some services can also remove, or filter portions of data (such as a row or column in a table) as well as create new “virtual” data such as headings and grouping rows. The service controller 205 can manage the “movement” of data as it proceeds from the data source 220 through processing by one or more services 225. For instance, in table data, the service controller 205 can manage selections of one or multiple rows, columns, and cells and provides methods to map such selections between the data consumer UI perspective and the data source's perspective. The service controller 205 can also rely, in some instance, on the individual services 225 to perform some of this management. For instance, services 225 can be responsible for retaining the selection information when the service configuration changes and to keep the mapping information consistent.
A single UI service 225 may be sufficient to perform the operation responsive to the service consumer's request 250, although in some instances, multiple UI services 225 will need to be called to complete an operation responsive to the request 250. Additionally, where multiple services are to be called, the service controller 205 can, in addition to identifying and selecting the appropriate services 225, orchestrate the manner and order in which each of the identified services 225 performs its respective operation on the data. Indeed, in some instances, it can be necessary to perform services 225 in a particular order in order to produce a result responsive to the service consumer's request 250. As an example, the UI framework can provide functionality for providing table UI operations.
Continuing with the example of
In the alternative example of
Returning to the example illustrated in
As one example, a service consumer 210 can request that the UI framework 200 perform a grouping and data conversion operation on data from a data source 220. In this example, the service controller 205 identifies the data source 220 as well as the capability of the data source to perform elements of the requested grouping operation. The UI framework may further determine that the capabilities of the data source 220 are suitable substitutes for certain services 225 that could be used to respond to the request 250. To conserve processing resources at the UI framework 200, the service controller can delegate the performance of certain operations, capable of being performed by the UI service 225, to a data source 220 capable of performing the same operations on the data 255. Additionally, the UI framework 200 can delegate UI operations in order to increase the overall efficiency of the response to a request 250. As an example, many UI operations can be implemented more efficiently if their execution is located “close” to the respective data source 220, such as by the data source 220 itself. Accordingly, the UI framework 200 may determine that it is preferable, from an efficiency standpoint, to delegate certain operations or services to the data source 220, where the data source 200 is available to perform these operations.
Delegating operations to the data source 220 can be optional. For instance, a service controller 205 may first seek permission from the data source 220 or determine a load on the UI framework before delegating UI operations to the data source 220. In some instances, a data source 220 may perform UI operations requested of it by the service controller 205, prior to transmitting the data 255 to the UI framework 200 for further processing. Additionally, in certain instances, the UI framework can delegate all of the UI operations needed to respond to a request 250 to a data source. In the example above, involving a request to group and convert table data, the service controller 205 communicates with the data source 220 and requests that the data source provide the requested data 255, operated upon by the data source 220 and grouped according to the parameters set forth in the request 250. The service controller 205 receives the processed data 255 and need only then manage the execution of those remaining services 225 needed to complete the data conversion portion of the request 225. In some examples, operations performed by a data source 220 on data 255 delivered to the UI framework 200 for further processing may need to be “finished,” or specially processed, by one or more services 225 capable of working with data that has been operated upon by a particular data source 220.
In addition to optimizing performance of the UI framework services 225 by delegating certain operations to a capable data source 220 when available, the service controller 205 can also be responsible for communicating with service behavior controllers 215. A service behavior controller 215 can specify and communicate the needs and conventions of a particular UI, on an operation-by-operation, or service consumer-by-service consumer basis. The service controller 205, can request 260 service behavior data from a service behavior controller as particular service events (e.g., a particular operation) are identified or performed. For instance, a particular UI of the service consumer 210 may only display a portion of a set of data on the UI at any given time. For example, the service consumer's UI may utilize a scrolling tool, displaying less than the entire data set, yet allowing the user to view the remaining data by interacting with the UI. Further, only a subset of data to be processed and returned 265 for display on the UI may be displayed at one time. However, in some instances, performance of a UI operation on data presented to a user can result in a change to the order or arrangement of the data as it was originally presented to a user. For instance, a sort or filter operation can re-order data. A service behavior, specified by a service behavior controller 215, can establish what portion of the data is displayed following the operation. For instance, in the example of a sort, a service behavior can dictate that following the sort, a user-selected row or top row of the table last displayed to the user, is to be positioned at the top of the set of returned data 265, even if the particular row is not the first, or “top” row of the data set after it has been sorted (e.g., alphabetically). As another example, in the case of a filter operation, certain rows may be hidden by virtue of the filter. A service behavior can dictate whether certain previously selected rows remain selected, whether only the remaining visible selected rows remain selected, or no row remains selected after filtering.
As a further example, illustrated in
The examples of
In some implementations, the UI framework 200 and hosted services 225 may adopt principals and/or rules of operation that assist in achieving and maintaining efficient and optimized performance. For instance, services can be directed to read and process only as much data as needed to answer the request. Services, in some instance, need not, and can be directed not to, perform unnecessary calculations. For instance, one or more services 225 may include or use a cache (not shown) to store intermediate or past results in order to fulfill performance requirements and optimize processing of later requests involving overlapping data sets. Utilizing such principals can extend the processing capabilities of the UI framework, allowing it to be used by multiple consumers on large and complex data sets.
Requests from service consumers 210 need not always require the UI framework to coordinate performance of UI operations on data 255 retrieved from a data source 220. Indeed, in some instances, a request from a service consumer can result in the UI framework interfacing with a data source 220 to request a modification to data managed and/or stored by the data source 220. Modifications to data can include updating, changing, deleting, or adding data to a data set provided by the data source 220. For instance, a data consumer application may receive a user request through its UI requesting that certain data, displayed to the user through the UI, be changed in accordance with the user's instructions or interactions. The UI framework 200, acting as an intermediary between the UI and the data source 220, can negotiate the performance of the user's request with the data source 220. In such instances, change information 270 can be transmitted to the data source 220 through, for example, the service controller 205.
In some instances, a service consumer request 250 can result both in the performance of UI operations on data 255 pulled from the data source as well as modifications to data stored at the data source 220. Multiple data sources 220 can be involved in the transaction, with data from one data source being pulled for UI operations and data from another data source being modified in response to the consumer's request 250. Indeed, any service consumer request can involve data from multiple data sources 220, for instance as data 255 from multiple data sources is pulled, by the UI framework, to assemble a data set upon which UI framework services will be performed to produce a processed set of data 265 returned to the consumer 210 for presentation on a UI. The service controller 205 can handle and coordinate each of these transactions between the various data sources 220 in response to a service consumer's request 250.
During or after processing of data 255 by one or more services 225, the data source 220 can additionally signal data changes to the service controller 205 indicating that insertions, deletions, and modifications of certain record values have been made, for example, by the underlying data source manager, the data consumer's underlying application, or another data consumer. Changes signaled by the data source 220 can invalidate any intermediate results or caches of the services. Likewise, the UI framework 200 can ask the data source 220 to insert, delete, or modify rows in connection with performance of its services 225.
In addition to managing and optimizing performance of the UI framework services 225, the service controller 205 can also cooperate and communicate with a field service controller 245 of the UI framework as well as a service configuration controller 235 of the UI framework in connection with providing UI services to consumers. Both controllers 235, 245 can be called on to perform necessary tasks used in responding to consumer requests for UI operation services managed by the service controller 205. Indeed, in some implementations, the functionality of two or more of the service controller 205, field service controller 245, and service configuration controller 235 can be combined into a single framework controller.
A field service controller 245 can be used in connection with one or more services 225 called in connection with the performance of various UI operations on data 255 obtained from a data source 220. A field service controller 245 can provide data conversion functionality, for instance, to convert the data type of data 255. For instance, data retrieved from the data source 220 may have a data type definition that is different or incompatible with either or both of the consumer's UI or the UI services 225 of the framework. Generally, the field service controller 245 performs data translation operations to translate the data type or format between its “external” type (i.e., how the data is presented on the UI) and its “internal” type (i.e., how the data is maintained at the data source 220), according to one or more rules dictating how the translation is performed. In some instances, data translation may be required by a particular UI operation or service 225 in order to properly respond to a request 250. For example, a service may not be able to properly sort or filter a given UI column, where the displayed, external values are time stamps in local time, while the internal values represent the times in normalized universal time (UTC). Accordingly, in some instances, there can be strong cooperation and coupling between the field service controller 245 and one or more services 225 provided through the UI framework 200.
Additionally, data translation can assist in translating data according to regional preferences. For instance, data can be translated based on the regional preferences of the UI and data source 220, including the language, alphabet, currency, units of measurement, date format, etc. For instance, by way of a simplified, non-limiting example, internal data at the data source may store monetary values in Euros while the UI of the service consumer displays the monetary values in US dollars. The field service controller 245 can perform the data translation, either when pulling data from, or writing data to the data source, by applying a current exchange rate converting the values between Euros and US dollars.
A centralized field service controller 245 need only perform data conversion once for a chain of services 225 and service operations. In some instances, a field service controller 245 can be implemented according to the specialized requirements of specific application programming models, for example where data type definitions differ amongst programming models. The requirements can be communicated, in some instances, by the application layer of a service consumer 210. Indeed, while the field service controller 245 is internal to the example UI framework 200 implementation illustrated in
Each UI service 225 has a corresponding service configuration model 230. A service's service configuration model 230 defines the exact function of a service, including the specific parameters and data range information needed by the service 225 to successfully perform its operation. As an example, the service configuration model 230 of a service for performing a sort table UI operation can, for example, include configuration parameters needed to perform the sort including an identification of the column(s) to be sorted, as well as parameters indicating how the data is to be sorted (e.g., descending/ascending, alphabetically, etc.).
The UI framework 200 can further include a service configuration controller 235 that provides an interface to external service configurators 240, to allow a service configurator 240 to modify or customize, permanently or temporarily, a particular service 225. This can be accomplished by providing service configurators 240 uniform and controlled access to a services' service configuration models 230 through the service configuration controller 235. A service configurator 240 can also create or define initial or default configuration models or configuration model parameters. For instance, a service configurator 240 can define a new configuration model for a new service needed in connection with the UI of a particular service consumer 220. In some examples, service configurators 240 can specify conditional configuration model modifications. For instance, a service configurator 240 can specify that a proposed configuration model modification or customization should be limited to a particular service consumer, data type, data source, etc. Changes to a particular service configuration model 230 can also be limited to apply only during a particular request 250, and modifications to configuration models 230 can take place at runtime, in response to or in connection with a particular request 250 for UI services. Indeed, the service consumer 210, itself, can act as the service configurator 240, and specify a change to a service configuration model in its request for a UI service. Additionally, a service configuration controller 235 can also permit external service configurators 240 to simply read current configuration models 230 of UI services 225 offered through a UI framework 200. Information concerning service configuration models 235 can be used, for example, by service consumers 210 in tailoring their requests 250 in accordance with a particular service configuration model 235.
While the example UI framework illustrated in
Turning to
A reusable, shared UI framework can receive multiple requests for UI services from multiple service consumers utilizing UIs of different technologies. Requests fielded by the UI framework from service consumers can involve the same sets of data provided by the same data sources. Where a service has already performed a particular operation on a set of data, the service can cache the result and use the cached result the next time an operation is requested on the set of data, for instance, by a different service consumer. Additionally, requests received from the same service consumer can require data from different data sources.
In some instances, a service provided by a shared UI framework can perform operations on an identified data set on a piece-wise basis. For instance, a large set of data may be identified in a request. The UI framework can divide the set into segments and perform UI operations on each segment to incrementally build the resulting set of processed data for the service consumer. As an example, only a portion of a large set of data, upon which UI operations are to be performed, may be presented on a service consumer's UI at a given time. Accordingly, the UI framework may subdivide a large block of data into smaller segments corresponding to the portion of that data block that can be displayed at a given time on the UI. In another example, the UI framework can identify that framework services have already performed the requested operation on portions of the data block, and cached the results, allowing the UI framework, in this transaction, to restrict performance of the operation to that portion of the block not yet operated upon.
In some instances, the request sent 610 can include other information including information about the data subset requested (e.g., page, start row in a table, end row in table, cell range, etc.), selections (e.g., multi- and single selections; rows, columns, or cell selections in tables, etc.), service configuration model change requests (such as new sort rules, for example), data modification requests (e.g., changes, additions, insertions, and deletions of data), and error information. Likewise, processed data received 615 from the UI framework can include supplemental data communicating aspects of the processed data returned to the requesting consumer (such as a page, start row in a table, end row in table, cell range, index key, etc. corresponding to the data), error information, or confirmation receipts detailing the operations performed, service configuration model changes and service behavior changes made, data modification made at the data source, etc.
Requests sent to a shared UI framework by a service consumer can also (or alternatively) include requests that cause the UI framework to perform other tasks beside UI service operations. For instance, a request sent to the UI framework can cause the UI interface to interface with a data source to modify, add, or delete data managed by the data source. The request can include or be directed to a request to modify a UI framework service's service configuration model. In some instances the request includes a service behavior request. In still other examples, a request can include requests for information from the UI framework, such as information about a service's service configuration model.
Continuing with the example of
A background spooling system 810 can be used in connection with the print converter 805. The background spooling system 810 can include stored application data 815 (e.g., application data of an application similar to that shown and described in
Although this disclosure has been described in terms of certain implementations and generally associated methods, alterations and permutations of these implementations and methods will be apparent to those skilled in the art. For example, the actions described herein can be performed in a different order than as described and still achieve the desirable results. As one example, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve the desired results. In certain implementations, multitasking and parallel processing may be advantageous. Other variations are within the scope of the following claims.
Braun, Michelle, Novak, Petr, Vollrath, Ivo, Scherer, Klaus-Dieter
Patent | Priority | Assignee | Title |
10088981, | Dec 29 2015 | SAP SE | User engagement application across user interface applications |
9274760, | Jul 11 2013 | SAP SE | Adaptive developer experience based on project types and process templates |
Patent | Priority | Assignee | Title |
7000238, | Oct 10 2001 | CODEGEAR LLC | Development system providing extensible remoting architecture |
7574511, | Mar 12 2004 | Bank of America Corporation | Methods, systems, and software for providing service integration framework |
7624145, | Jan 06 2007 | Microsoft Technology Licensing, LLC | Persistent collaborative framework for interactive web applications |
7685561, | Feb 28 2005 | Microsoft Technology Licensing, LLC | Storage API for a common data platform |
7739691, | Apr 29 2005 | Microsoft Technology Licensing, LLC | Framework for declarative expression of data processing |
7757205, | Sep 16 2002 | Siemens Aktiengesellschaft | System for preparing a standard framework for automation appliances |
7895338, | Mar 15 2004 | Siemens Corporation | Meta-search web service-based architecture for peer-to-peer collaboration and voice-over-IP |
20040187140, | |||
20080028329, | |||
20100122065, | |||
20100146420, | |||
20110320970, |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Jun 29 2010 | SAP AG | (assignment on the face of the patent) | / | |||
Oct 04 2010 | VOLLRATH, IVO | SAP AG | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 029934 | /0733 | |
Oct 04 2010 | SCHERER, KLAUS-DIETER | SAP AG | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 029934 | /0733 | |
Oct 04 2010 | NOVAK, PETR | SAP AG | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 029934 | /0733 | |
Oct 11 2010 | BRAUN, MICHELLE | SAP AG | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 029934 | /0733 | |
Jul 07 2014 | SAP AG | SAP SE | CHANGE OF NAME SEE DOCUMENT FOR DETAILS | 033625 | /0334 |
Date | Maintenance Fee Events |
Sep 27 2016 | M1551: Payment of Maintenance Fee, 4th Year, Large Entity. |
Sep 18 2020 | M1552: Payment of Maintenance Fee, 8th Year, Large Entity. |
Date | Maintenance Schedule |
Apr 09 2016 | 4 years fee payment window open |
Oct 09 2016 | 6 months grace period start (w surcharge) |
Apr 09 2017 | patent expiry (for year 4) |
Apr 09 2019 | 2 years to revive unintentionally abandoned end. (for year 4) |
Apr 09 2020 | 8 years fee payment window open |
Oct 09 2020 | 6 months grace period start (w surcharge) |
Apr 09 2021 | patent expiry (for year 8) |
Apr 09 2023 | 2 years to revive unintentionally abandoned end. (for year 8) |
Apr 09 2024 | 12 years fee payment window open |
Oct 09 2024 | 6 months grace period start (w surcharge) |
Apr 09 2025 | patent expiry (for year 12) |
Apr 09 2027 | 2 years to revive unintentionally abandoned end. (for year 12) |