The Fluid component framework will consist of a number of technologies and APIs for building flexible user interfaces. The framework can be broken down into four main aspects:
- The component model and APIs
- The component container
- The server-side binding layer
- The run-time transformation engine.
The framework defines the core infrastructure that allows developers and UI designers to create, customize, and reuse UIcomponents across applications. This framework enforces loose coupling and the separation of user interface behaviour from underlying application logic, allowing UI developers to focus on creating lightweight components that offer a richly transformable user experience. This framework goes more than "skin deep," providing a means to customize the presentation of an application including substituting and re-aggregating both the look and behaviour of components.
The component framework will be implemented using a blend of client-side AJAX along with a standardized layer for communicating between client and server. This approach facilitates the integration of the framework into server-side presentation technologies such as RSF and uPortal's XSLTlayer. A specification for binding components to the data and services running on the server will be defined, and specific implementations will be developed using RSF for Sakai and with Java and XSLTfor uPortal and Kuali Student. This binding layer ensures that components are not dependent on the underlying programming language or presentation technologies used by the application. The framework will make use of REST (Representational State Transfer) or similar remoting technologies to ensure that client/server communication is both simple and efficient.
The Component Container also interacts with the Run-time Transformation Engine, which is responsible for dynamically transforming and re-binding the interface based on user preferences. This transformation process includes the addition, substitution, removal, and reconfiguration of the user interface at run-time. The engine matches, assembles and delivers the collection of appropriate user interface components and ensures that they are correctly and securely bound to the underlying application server layer.
Component Framework Schematic
Figure 1: The main component framework collaborators at run-time, including a group of related components managed by the component container, the transformation engine, and the communication layer between the client and server sides.
Overview of the Framework
1. Component Model & APIs
2. Component Container
3. Server-side Binding Layer
The server-side binding layer provides a specification for how communication between the client and server should occur in order to allow Fluid components to be used across applications implemented with different presentation technologies. This layer encapsulates access to server-side application logic, defining conventions through which the client tier can read and modify resources on the server.
Two main implementations of the server-side binding layer specification will be created. A reference implementation will be written using Java and RSF that can be used directly by Sakai, and another implementation using Java and XSLT written in collaboration with the uPortal and Kuali Student communities.
4. Run-time Transformation Engine (Matcher and Aggregator)
< Previous | Next >