1. Designing Context-Sensitive User Interfaces

2. Overview Introduction Context Architectures DynaMo-AID: designing context-aware user interfaces  Design Process  Runtime Architecture Demo Prototype DynaMo-AID

3. Introduction Static vs. Dynamic Context Dynamic Context  Considering at design time  Considering at run-time StaticDynamic Context information does not change while the user interface is presented Context information is updated during the run-time of the application e.g. only considering static migration of the user interface e.g. dynamic distribution of the user interface

4. Introduction Adaptivity of the UI should be considered in early design stages  [Dey] A system is context-aware if it uses context to provide relevant information and/or services to the user, where relevancy depends on the user’s task  Considering adaptivity in task design  Model-Based User Interface Development (D5.1) Mobile Computing Embedded Systems Wireless Communication Pervasive Computing Ubiquitous Computing Ambient Intelligence Context-Awareness

5. Introduction Context  Sensor-Based  Abstraction/Interpretation layers  Agents (Software/User)  Simulation  Services Service [Coulouris et al.] (WP4) A distinct part of a computer system that manages a collection of related resources and present their functionality to users and applications Effects on Model-Based UI Design  Integrating adaptivity in early design phases Frequent/Common changes  Prepare interactive applications for services Infrequent/Unpredictable changes

6. Context Architectures Classification [Winograd]  Networked services  Blackboard approach  Widget-based Context Fabric [Hong] (networked services) Pervasive Computing Architecture [Henricksen] (blackboard approach) Context Toolkit [Dey & Salber] (widget-based) Our Approach: DynaMo-AID  Integrating the Context Architecture into a User Interface Architecture

7. Comparison Context ToolkitPervasive Computing Architecture DynaMo-AID

8. Dynamic Model-Based User Interface Design  Design Process (tool support)  Runtime Architecture

9. DynaMo-AID Design Process

10. Task Model Extended ConcurTaskTrees Notation Abstract Interaction Application User Decision Temporal Relations Decision Task  one sub tree for each context of use  service tasks

11. Task Model

12. Dynamic Application Model Dynamic Application Core Services  Annotated with Task Models describing the interaction enabled by the service  influence on Task Model  Context Sensing services  influence on Environment Model

13. Dynamic Environment Model Collection of “Context Objects” 2 abstraction levels  Concrete Context Object (CCO) Encapsulate rough sensor data e.g. Temperature = 23 degrees Celsius  Abstract Context Object (ACO) Abstract context data e.g. Mobile Phone in hand Designer links ACOs to Task Model (decision tasks)

14. Dynamic Environment Model

15. Dialog Model For each CTT in Forest:  DynaMo-AID extracts subatomic dialog model with intra-dialog transitions Designer specifies inter- dialog transitions

16. Presentation Model Abstract Level: UI building blocks attached to unit tasks Concrete Presentation Units:  Groups of tasks (enabled task sets)  One dialog: visualized enabled task set

17. DynaMo-AID Runtime Architecture

18. The Context Control Unit (CCU) 1. Detect context changes 2. Recalculate ACO  CCO mapping 3. Select current context- specific task model 4. Execute inter-dialog transition

19. DynaMo-AID fast prototyping tool

20. Demo Context-Sensitive Mobile Phone  Sensors detect current context  3 states: Table Pocket Hand  Inter-Dialog Transitions

21. Demo: Task Model

22. Demo: Context Switch