The CAMELEON reference framework

In this section, we introduce the CAMELEON [26,27] reference framework, that provided the theoretical background for different model-based languages for user interfaces (MBUI), and in particular for the definition of MARIA [111], which we discuss more in detail in Chapter 6, since in this dissertation we define an extension for supporting gestural interaction, which can be therefore inserted into the broader scope of MBUI approaches. The CAMELEON Reference Framework offers a unified representation of the models, methods and processes for creating multi-target user interfaces. The UI context of use is defined along three dimensions: the users that are intended to use or effectively use the system, the platform that is the hardware and software configuration of the interactive system, and the

environment that specifies the physical conditions where the interaction

occurs. A multi-target UI is able to support different contexts of use. The reaction to a context change in a multi-target UI is called adaptation. If the adaptation is performed preserving usability, the UI is plastic. Preserving UI plasticity for cross-platform design and for context-aware applications is currently one of the main challenges in this research field. Indeed in [121], the authors demonstrated through a case study that the overall UI quality (in terms of ergonomic criteria) increases when the UI plasticity is preserved. This happens since plasticity has an impact on a set of usability criteria that influence positively different usability aspects.

Given the increasing number of devices that people uses in their everyday life, the engineering techniques able to preserve plasticity from the early phase of the applications development have an impact on different fields of Computer Science [28], and their number will increase in the future. Besides HCI, fields such as Software Engineering (e.g. aspect-oriented programming, model-driven-engineering) and Artificial Intelligence can provide effective solutions for this problem.

2.4.2THE CAMELEON REFERENCE FRAMEWORK 51

With respect to the application modelling, the CAMELEON framework distinguishes three kinds of models. The ontological models are defined as the meta-models, independent from any interactive system, which are able to describe the concepts and their relationship involved in multi-targeting. The archetypal models are instantiations of the ontological models and represent an interactive system that deals with a given domain. The

observed models are executable models that support the adaptation process

at run-time.

The ontological models can be of three different types:

1. Domain Models, which support the description of a domain-related concepts and tasks.

2. Context Models, which support the description of the context (user, platform and environment).

3. Adaptation Models, which support the description of the reactions in case of context change and the commutation process.

After the identification or the specification of the needed meta-models (e.g. UML class diagram for describing the domain-concepts, CTT for describing the tasks etc.), it is possible to define various configurations that describe a specific interactive system using the different meta-model constructs. This instantiation of the ontological model produces different archetypal models, which represent the application for classes of potential devices (e.g. the archetypal model for a multi-touch mobile device applies for the iPhone, Samsung Galaxy S4 etc.). The observed models are exploited at runtime in order to perform both the UI execution and the context switches.

The design-time phase creates a set of executable UIs, each one targeted to a particular archetypal model configuration, called initial model. The process envisions the creation of a set of different transient models, produced using different operators. At the end of the process, we have the final context-sensitive interactive system.

The framework specifies four different transient models, with a decreasing level of abstraction:

 Concepts and Tasks model: description of the concepts and the tasks that is produced by the designer for a particular context of use.

 Abstract User Interface (AUI): user interface description that is independent with respect to the device and the interaction modality.

 Concrete User Interface (CUI): user interface description that is abstract with respect to the technology used for the implementation.

 Final User Interface (FUI): the final implementation of the user interface, expressed in source code.

The operators transform a model into another one. Such transformation can be implemented in different ways: with a completely automatic process, without any automatic support (completely defined by a designer), or with a semi-automatic solution. The latter process envisions the automatic creation of a target model draft, with an intervention of a designer, which modifies it in order to achieve the desired result. On one hand, a full automation leads to a very quick development process. However, this produces only standard solutions that are not tailored for the specific application, otherwise the designer should specify a huge number of details that invalidates the model convenience. On the other hand, a completely manual solution has a high development cost that would make the multi- targeting expensive. It is a general opinion that a good balance between the automation and human intervention is the best solution for this problem.

Operators can be classified according to the abstraction level of the models involved in the transformation process:

 An operator performs a vertical transformation if the source and the target models are at different levels of abstraction. The top- down approach (from a higher level to a lower one) is called

reification, while a reverse engineering step is called abstraction.

 An operator performs a horizontal transformation if the source and the target models are at the same abstraction level. If it involves two different targets, it is called translation.

In the run-time phase, the designed UIs and the runtime infrastructure cooperate in order to support the adaptation. The process consists of three steps that include the recognition of the situation, the computation of a reaction and the execution of the reaction.

The recognition of the situation needs the ability to sense the context of use (or at least the part that are interesting for triggering a change), to detect context changes (comparing the sensed attributes with the previous values) and to identify context changes (classifying the change into the modelled categories).

2.4.3CONCURTASKTREES 53