π Lecture 7 β Pervasive Application Development
π Overview: This lecture explains why developing pervasive applications is fundamentally more difficult than conventional application development. It covers the major challenges posed by device heterogeneity, dynamic application environments, and introduces approaches to manage the complexity of developing applications that must work across multiple devices, modalities, and connectivity scenarios.
ποΈ Topics Covered
The lecture begins by outlining the fundamental reasons for increased difficulty in pervasive application development, then explores four key aspects of device platform heterogeneity: user interface differences, interaction modalities, platform capabilities, and connectivity issues. It then discusses the dynamics of application environments, focusing on context awareness and the complexity of handling diverse context sources. Finally, it introduces approaches for developing pervasive applications to address these challenges.
π Lecture Summary
Heterogeneity of Device Platforms
End user devices like smartphones and PDAs come in many varieties with widely varying capabilities, both hardware (form factor, user interface hardware, processor, memory, network bandwidth) and software (operating system, user interface software, services, and applications). The impact of device heterogeneity on application developers is that applications need to be developed (or ported) to each device and maintained separately for each device.
User Interface differences include output capabilities such as screen characteristics (size and color), input capabilities like the number of hard buttons, rollers, and other controls, and the software toolkit available to manipulate these input and output capabilities. Because of differences in these capabilities from one device to another, the view component of an application will have to be rewritten for each device.
Interaction Modalities represent significant methods of user interaction. Examples are keyboard or mouse, speech, pen, and tactile interfaces. The view and controller portions of applications may need to be significantly rewritten to enable each modality. For example, a speech-based application could have a different structure from a GUI-based application. Furthermore, multimodal interfaces can use multiple modalities within a single application.
Platform Capabilities refer to the distributed software infrastructure on which an application executes, including the device software infrastructure and the server software infrastructure. The programming models on the device and the server are different. An application may need to be partitioned differently between the device and the server depending on the processor, memory, and network capabilities of a device.
Connectivity requires applications to execute in a dynamic environment that supports multiple levels of connectivity. Developers must worry about dynamically varying the partitioning of the application between the various connectivity scenarios and resynchronizing partitioned components after reestablishing connectivity. This adds a significant amount of complexity.
π‘ Why this matters: Each of these four dimensionsβUI, modalities, platform capabilities, and connectivityβforces developers to rewrite the same application multiple times, dramatically increasing development cost and maintenance effort.
Dynamics of Application Environments
Pervasive applications should be customized to the user and task at hand β also referred to as the context of the application. The context can be highly dynamic. The data sources that provide information about the applicationβs environment are called context sources.
Consider the complexities of application development in the face of dynamic and heterogeneous context sources. The context data from different context sources could have different schemas and formats. For example, location data from a cell tower is different from the location data from an IEEE 802.11 base station. If each pervasive application that uses context data were responsible for collecting and normalizing context data from different sources, applications would indeed be quite complex.
The context information from any one source could be too low-level to be useful for an application. The actual context sources themselves could be highly dynamic. For example, the location of a person can be obtained by a multitude of sources, including a cell tower, a telematics gateway, a wireless local area network (LAN) hub, and an active-badge access point. Each of these sources of location may have a different API and may be more or less applicable to different locations. Applications should not be responsible for discovering these context sources and explicitly binding to them.
π‘ Why this matters: If every application had to directly handle all context sources, their different APIs, formats, and dynamics, development would be unmanageably complex. This motivates the need for middleware or infrastructure that abstracts context handling.
Approaches for Developing Pervasive Applications
The basic problem of mobile application development to multiple devices, modalities, and connectivity environments is that of complexity, because the same application may have to be rewritten multiple times.
π Definition β Device Heterogeneity: The variety in hardware (form factor, UI hardware, processor, memory, network bandwidth) and software (operating system, UI software, services, applications) capabilities across different end user devices like smartphones and PDAs.
π Definition β Context: The information about the user and task at hand that allows pervasive applications to be customized dynamically.
π Definition β Context Sources: The data sources that provide information about the application's environment, such as cell towers, Wi-Fi base stations, telematics gateways, and active-badge access points.
π Definition β Multimodal Interfaces: Interfaces that can use multiple interaction modalities (e.g., keyboard, speech, pen, tactile) within a single application.
β Key Takeaways
The core challenge in pervasive application development is device heterogeneity across hardware and software, requiring separate development or porting for each device. Developers must address differences in user interfaces, interaction modalities, platform capabilities, and connectivity dynamicsβeach potentially forcing significant rewriting of application components. Context-aware applications face additional complexity from dynamic, heterogeneous context sources that have different APIs, schemas, and formats, making it impractical for each application to handle context collection directly. The fundamental problem is complexity: the same application logic may need to be rewritten multiple times for different devices, modalities, and connectivity scenarios. These challenges drive the need for approaches and frameworks that abstract away device-specific and context-specific details from application developers.
π§ Quick Revision Questions
- What are the four main aspects of device platform heterogeneity discussed in the lecture?
- Why must the view component of an application be rewritten for each device?
- What is a "multimodal interface" and why does it add complexity to development?
- What are context sources, and why is it problematic for applications to bind directly to them?
- What is the fundamental problem that all these challenges (heterogeneity, context dynamics, connectivity) boil down to for pervasive application developers?
π Lecture 8 β Heterogeneity of Device Platforms
π Overview: This lecture examines the fundamental challenge of device platform heterogeneity in pervasive computing and its impact on application development. It explores the dynamics of application environments, particularly context awareness, and presents architectural approaches for building applications that can adapt across multiple device platforms, modalities, and connectivity environments.
ποΈ Topics Covered
The lecture covers three main areas: the impact of device heterogeneity on application developers requiring separate development for each device; the dynamics of application environments including context sources, their heterogeneity, and dynamic nature; and approaches for developing pervasive applications using platform-independent view, controller, and model components with presentation transcoding and different client-server architectures.
π Lecture Summary
Heterogeneity of Device Platforms
The impact of device heterogeneity on application developers is that applications need to be developed (or ported) to each device and maintained separately for each device. This creates significant development overhead and maintenance burden.
π Definition β Device Heterogeneity: The condition where different devices have varying hardware capabilities, operating systems, screen sizes, input methods, and APIs, requiring separate application versions for each device platform.
π Example: A mobile application must be developed separately for iOS, Android, and Windows Phone, each with its own programming language, UI framework, and distribution channel.
Dynamics of Application Environments
Pervasive applications should be customized to the user and task at hand β also referred to as the context of the application. The context can be highly dynamic. The data sources that provide information about the applicationβs environment are called context sources.
Consider the complexities of application development in the face of dynamic and heterogeneous context sources. The context data from different context sources could have different schemas and formats.
π‘ Why this matters: If each pervasive application that uses context data were responsible for collecting and normalizing context data from different sources, applications would indeed be quite complex.
π Example: Location data from a cell tower is different from the location data from an IEEE 802.11 base station. Each source has a different API and may be more or less applicable to different locations.
The actual context sources themselves could be highly dynamic. For example, the location of a person can be obtained by a multitude of sources, including a cell tower, a telematics gateway, a wireless local area network (LAN) hub, and an active-badge access point. Applications should not be responsible for discovering these context sources and explicitly binding to them.
Approaches for Developing Pervasive Applications
The basic problem of mobile application development to multiple devices, modalities, and connectivity environments is that of complexity, because the same application may have to be rewritten multiple times.
Platform-Independent View Component
Presentation transcoding is used to adapt the view component across different device platforms.
Platform-Independent Controller Component
The controller of an application represents the control flow, including data validation and error handling, typically via event handlers. To address the full range of applications, it is necessary to consider the role of the controller in modern interactive applications. There are several reasons why the controller of an application needs to be targeted to multiple devices.
Host-Independent Model Component
How to deal with the heterogeneity of connectivity environments: Networked mobile applications vary in the distribution of logic and data between the mobile device and the server.
π Definition β Thin-client application: Views are generated on the server and then rendered on the client device by a component such as a Web browser. Controller logic, model logic, and model data all reside on the server, so disconnected operation is impossible.
π Definition β Thick-client application: The model still resides on a server, perhaps accessed through Web services, but the rest of the application resides on the client device. Caching of data before connection and queuing of updates to be performed upon reconnection enable limited forms of offline operation in a weakly connected environment. The operations allowed are those that can proceed sensibly in the absence of a complete and current model.
π Definition β Autonomous-client application: An application that resides entirely on the client device. It maintains its own fully functional model, which may be synchronized from time to time with replicas of the model on a server.
β Key Takeaways
Device heterogeneity forces developers to create and maintain separate application versions for each target platform, substantially increasing development costs and complexity. Context-aware pervasive applications must handle highly dynamic context sources with different schemas, formats, and APIs without requiring applications to manage discovery and binding themselves. The Model-View-Controller (MVC) architecture can be adapted for pervasive computing by creating platform-independent components, including presentation transcoding for views and targeted controllers for different devices. Finally, the distribution of logic and data between client and server varies along a spectrum from thin-client (server-centric, no offline capability) through thick-client (limited offline via caching) to autonomous-client (fully client-side with synchronization).
π§ Quick Revision Questions
- What is the primary impact of device heterogeneity on application developers?
- What is meant by "context sources" in pervasive computing, and why is their heterogeneity a challenge?
- How does presentation transcoding address the problem of multiple device platforms?
- What are the key differences between thin-client, thick-client, and autonomous-client applications in terms of where model logic and data reside?
- Why should pervasive applications not be responsible for discovering context sources and explicitly binding to them?
π Lecture 9 β Host-Independent Model Component
π Overview: This lecture explores the architecture of autonomous-client applications that maintain their own fully functional models on mobile devices, and examines the runtime infrastructure needed for disconnectable applications. It also introduces the principles of developing context-aware and pervasive software, focusing on source-independent data and device-independent views.
ποΈ Topics Covered
The lecture covers the host-independent model component for autonomous-client applications, including the runtime infrastructure required for disconnectable applications. It then addresses developing context-aware applications, their triggering and effecting aspects, and three sources of complexity. The concept of source-independent context data is introduced, explaining how applications can specify desired data without naming specific sources. Finally, it outlines four key principles for developing pervasive software: device-independent views, platform-independent controllers, host-independent models, and source-independent context data.
π Lecture Summary
Host-Independent Model Component
An autonomous-client application resides entirely on the client device and maintains its own fully functional model, which may be synchronized from time to time with replicas of the model on a server.
There is a significant level of runtime infrastructure needed for disconnectable applications:
- An application hosting and execution environment is needed on the mobile device.
- If application code is to be downloaded from the server to clients upon demand, a code-migration component is needed on the server and device sides to coordinate the partitioning and loading of application components.
- A data synchronization component is needed for updating both the device and server instances of the application with changes to the data on the other sites and to resolve any possible conflicts.
Developing Context-Aware Applications
A context-aware application can be thought of as having a triggering aspect and an effecting aspect. The triggering aspect binds to data sources, collects data, analyzes the data, and ensures that the data is relevant to the application. If so, it notifies the effecting aspect, which takes the action corresponding to the trigger.
Context-aware applications have three sources of complexity:
- The heterogeneous nature of data sources
- The dynamic nature of context sources
- The multiple sources of potentially low-level context data
These complexities are all in the triggering component of applications.
π‘ Why this matters: Understanding these complexity sources helps developers design more robust context-aware systems that can handle diverse, changing, and low-level data inputs.
Source-Independent Context Data
An application obtaining data from heterogeneous sources with inconsistent availability and quality of service should not name a specific source of data. Rather, it should describe the kind of data that is required, so that the underlying infrastructure can discover an appropriate source for the data.
The basic idea is for an application to specify the desired context data without specifying the exact location and data type of the source, or whether it is coming from multiple sources. These considerations are handled transparently by the infrastructure.
Some data sources are passive or pull-based (e.g., request-response Web services), while other data sources are active or push-based (e.g., sensors that trigger alarms). Flexible infrastructure is capable of discovering both kinds of data sources. An application can then pull the current value from a passive data source or subscribe to be notified each time an active data source generates a new value.
Developing Pervasive Software
Four key principles for developing pervasive software:
-
Device-independent views β These allow an application to capture the basic interaction structures that should be reused across multiple devices and modalities. They should be combined with the ability to fine-tune the presentation when necessary.
-
Platform-independent controllers β These allow an application to specify the overall control flow across multiple execution platforms, but still allow an application to have different control flow structures for different devices and uses.
-
Host-independent models β These allow an application to encapsulate the business logic and data in a manner that can be reused regardless of which host a component is instantiated on.
-
Source-independent context data β This allows an application to specify the intended context data to be supplied by reusable infrastructure components, which in turn are concerned with the specific data formats, locations, and combinations of physical data sources that provide the actual data.
β Key Takeaways
Autonomous-client applications need significant runtime infrastructure including hosting environments, code-migration components, and data synchronization components. Context-aware applications have three key complexity sources: heterogeneous data sources, dynamic context sources, and multiple low-level data sources. Source-independent context data allows applications to specify required data without naming specific sources, with infrastructure handling discovery transparently. For pervasive software development, four principles are essential: device-independent views, platform-independent controllers, host-independent models, and source-independent context data. The triggering aspect of context-aware applications collects and analyzes data, while the effecting aspect takes corresponding actions.
π§ Quick Revision Questions
- What are the three main components of runtime infrastructure needed for disconnectable applications?
- What are the two aspects of a context-aware application and what does each do?
- What are the three sources of complexity in context-aware applications?
- What is the difference between passive/pull-based and active/push-based data sources?
- List and briefly describe the four principles for developing pervasive software.
π Lecture 10 β Hardware Platforms
π Overview: This lecture explores the hardware platforms powering mobile devices, with a primary focus on the Symbian operating system's architecture and evolution. It provides a foundational understanding of how operating systems manage hardware resources and how Symbian's layered system model enables smartphone functionality.
ποΈ Topics Covered
The lecture covers projected shipments of mobile hardware, an overview of major smartphone operating systems, a detailed exploration of Symbian's releases and architecture, a crash course on operating system fundamentals including kernels and APIs, and an in-depth breakdown of Symbian's layered system model encompassing the OS, Middleware, and Applications layers.
π Lecture Summary
Hardware Platforms: Projected Shipment & OS Overview
The lecture begins with projected shipments for mobile device categories: Cell Phones (little above 1600M units), Smart Phones (400M units), and Laptops (200M units). It then lists the major Operating Systems for Smartphones: Symbian, Windows Mobile, Blackberry OS, Android, and iOS.
Symbian
Symbian was developed by Symbian Ltd and runs exclusively on ARM processors (an unreleased x86 version exists). It is the successor to Symbian OS and Nokia Series 60, designed specifically for smartphones. Maintained by Nokia, it is an Open Source Operating System and Software Development Platform and belongs to the Embedded Operating Systems Family.
Symbian releases are styled as Symbian^1, Symbian^2, etc.:
- Symbian^1: The first release, forms the basis for the platform. It incorporates Symbian OS and S60 5th Edition (Symbian OS 9.4).
- Symbian^2: The first royalty-free version. On June 1, 2010, Japanese companies including DoCoMo and Sharp announced smartphones using Symbian^2.
- Symbian^3: Announced on 15 February 2010, designed as a more "next generation" smartphone platform. It introduced a new 2D and 3D graphics architecture, UI improvements, and support for external displays through HDMI.
- Symbian^4: Expected for release in first half of 2011, but Nokia announced in October 2010 it would not ship separately. Instead, improvements would be delivered as software updates to all current Symbian^3 devices.
π Definition β Operating System: A software, consisting of programs and data, that runs on computers and manages computer hardware resources, providing common services for efficient execution of various application software.
π Definition β Kernel: A bridge between applications and the actual data processing done at the hardware level. The kernel's responsibilities include managing the system's resources (communication between hardware and software resources).
π Definition β Application Programming Interfaces (APIs): The functionality provided by the Windows API can be grouped into eight categories: Base Services, Advanced Services, Graphics Device Interface, User Interface, Common Dialog Box Library, Common Control Library, Windows Shell, and Network Services. Additional API categories include Web, Multimedia, Program interaction, and Wrapper Libraries.
π‘ Why this matters: Understanding the OS, kernel, and APIs is foundational for grasping how mobile operating systems like Symbian manage hardware and enable application development.
Symbian β Architecture: System Model Structure
The System Model Structure of Symbian uses Technology domains and packages, reflecting the organization of a modular software stack. Key structural elements include:
- Layers: The fundamental stacking of software. Each layer abstracts the ones below.
- Levels within layers: Group packages by intended audience.
- Packages: Self-contained technologies. Levels within packages show their internal software stack.
- Collections: Logical groupings of related components.
- Components: The atomic unit of software architecture.
Symbian β Foundation Layers
The architecture defines three Symbian Foundation Device layers: OS (Operating System), Middleware, and Applications. Additional layers may be added with Architecture Council approval. Vendors may add their own layers, but these can only contain non-contributed, vendor-specific packages.
Foundation Device Layers β OS: This layer provides APIs that abstract the hardware platform, allowing higher layers to be isolated from hardware changes. It contains lower-level APIs that are not hardware abstractions but are used within the OS layer. This layer is sufficient to develop a test platform. It has two levels:
- hw: The kernel, interfaces to the hardware and user-side services. This level is sufficient to be an operating system (including filesystems, essential drivers, and a program execution model).
- services: Essential services necessary for a phone. Contains communications, text and data handling, graphics, etc.
Foundation Device Layers β Middleware: Provides higher-level generic APIs usable by programs in the application layer. Includes native UI frameworks, application lifecycle, higher-level protocols and data handling, etc. Middleware components are independent of the hardware platform (MW APIs are not used by the OS layer). It has two levels:
- generic: Services intended for any class of application. Examples include Text entry, security, and GUI widgets. This level and below is a general purpose computer.
- specific: Services intended for a specific class of application. Examples include Presence (mainly used by instant messaging apps) and the Phone Server (expected to only be used by a Phone application). This level and below is sufficient for phone application development.
Foundation Device Layers β Applications: Primarily contains interactive UI applications. Includes non-interactive applications (daemons) that respond to events from other than the device user (e.g., from a PC). It has two levels:
- services: Non-interactive applications, services provided to other packages. This level and below is sufficient to create applications which work together.
- apps: Applications which interact with the user. This level and below is the full set of software on the device.
- Packages which span both levels provide user-facing applications and services to other applications.
- Example: Contacts Apps provides the user-facing Phonebook application, plus the Contact Model which has an API for programmatically accessing contacts.
β Key Takeaways
This lecture covers the hardware shipment landscape and major smartphone operating systems, with Symbian as the central case study. You must understand Symbian's evolution through its numbered releases (^1 through ^4) and the key features of each. Critically, memorizing the three-layered Symbian architecture (OS, Middleware, Applications), their specific purposes, and the two sub-levels within each layer is essential for the exam. Recall that the OS layer abstracts hardware and includes kernel-level (hw) and essential phone services (services); the Middleware layer provides generic and specific APIs independent of hardware; and the Applications layer houses both user-facing apps and non-interactive service applications.
π§ Quick Revision Questions
- What are the three key layers (and their two sub-levels each) in the Symbian Foundation Device model?
- How does Symbian^3 differ from Symbian^1 in terms of features?
- What is the role of the kernel in an operating system, and how does it relate to APIs?
- In the OS layer, what is the purpose of the "services" level, and give two examples of what it contains?
- Explain the difference between "generic" and "specific" levels within the Middleware layer, using one example for each.
π Lecture 11 β Symbian Design Patterns
π Overview: This lecture explores the architectural design patterns and layered structure of the Symbian operating system for mobile devices. It explains how design patterns like microkernel and client-server, along with frameworks and idioms, create a robust, modular software stack. This matters for understanding how mobile operating systems balance performance, security, and extensibility.
ποΈ Topics Covered
The lecture begins with an introduction to Symbian design patterns, covering the microkernel pattern, client-server pattern, frameworks, graphical and event-based application models, robustness idioms, streams and stores for data persistence, and the class library. It then delves into the Symbian architecture, explaining system model structure, technology domains, and packages. The foundation layers are described in detail, including the UI Framework, Application Services, OS Services, Base Services, and Kernel Services layers, along with the principles of layer abstraction and dependency flow.
π Lecture Summary
Symbian Design Patterns
The lecture introduces key design patterns used in Symbian OS. The microkernel pattern is a core architectural choice where the kernel is kept minimal, providing only essential services, while other services run as user-mode servers. The clientβserver pattern is used extensively, where clients request services from servers, enabling modularity and isolation. Frameworks provide reusable, extensible skeletons for applications. The graphical application model and event-based application model define how applications handle user input and screen updates. Specific idioms aimed at improving robustness include patterns for handling memory allocation failures and resource cleanup. Streams and stores provide mechanisms for persistent data storage, and the class library offers a comprehensive set of reusable C++ classes.
π Definition β Microkernel pattern: An operating system architecture where the kernel provides only the most basic services (e.g., memory management, process scheduling) and other services (e.g., file systems, networking) run in user space as separate servers. π‘ Why this matters: This pattern increases system stability and security because a failure in a server does not crash the entire kernel.
Symbian β Architecture
The system model reflects the organization of a modular software stack. Layers are the fundamental stacking of software, where each layer abstracts the ones below. Levels within layers group packages by intended audience. Packages are self-contained technologies, and levels within packages show their internal software stack. Collections are logical groupings of related components. Components are the atomic unit of software architecture.
π Definition β System Model Structure: The organization of Symbian OS into technology domains and packages, following a modular software stack approach with layers, levels, packages, collections, and components.
π Architecture Principle: Layers abstract lower-level services β higher layers build upon lower layers, with dependencies flowing downward and notifications flowing upward.
Symbian β Foundation Layers
The three Symbian Foundation Device layers are: OS, Middleware, and Applications. Additional layers may be added with Architecture Council approval. Vendors may add their own layers if needed, but vendor's layers can only contain non-contributed, vendor-specific packages.
π Definition β Foundation Layers: The three primary layers (OS, Middleware, Applications) that form the base of the Symbian device software stack.
Symbian OS Model
The UI Framework Layer provides the frameworks and libraries for constructing a user interface. The Application Services Layer includes system-level services for text handling, services that support generic types of applications (like Alarm Server and data synchronization), and services based on more generic but application-centric technologies like mail, messaging, and browsing. The OS Services Layer provides generic operating system services, communications services, multimedia and graphics services, and connectivity services. Below these are the Base Services Layer and the Kernel Services and Hardware Interface Layer.
π Definition β OS Services Layer: The layer providing generic OS services, communications, multimedia/graphics, and connectivity to higher layers.
Symbian β Architecture (Layered Principles)
All services provided by a layer are at a similar level of abstraction. A layer provides services to higher layers ('upwards') and delegates tasks to lower layers ('downwards'). Dependencies flow consistently from higher layers to lower layers (but dependencies are allowed sideways within layers). Requests travel downwards, while notifications travel upwards. Higher layers abstract the services of lower layers away from machine-centric services towards user-visible functionality. A layer provides services as far as possible via well-defined external interfaces, which can be separated from the internal interfaces available within the layer.
π Principle: Requests travel downwards (from UI to Kernel), notifications travel upwards (from Kernel to UI).
β Key Takeaways
The Symbian architecture is a modular, layered software stack where each layer abstracts the services below it, enabling separation of concerns and portability. Design patterns like microkernel and client-server are fundamental to Symbian's robustness, ensuring that failures in user-space servers do not crash the core operating system. The three foundation layers (OS, Middleware, Applications) are supplemented by vendor-specific layers that can only contain proprietary, non-contributed packages. Dependencies in the system flow consistently from higher to lower layers, while requests move downward and notifications move upward, creating a predictable and manageable system structure. The class library and patterns for data persistence (streams and stores) are essential for building reliable mobile applications that can handle resource constraints and crashes.
π§ Quick Revision Questions
- What is the microkernel pattern and why is it used in Symbian OS?
- In the Symbian layered architecture, what is the direction of request flow and notification flow?
- Name the three primary Symbian Foundation Device layers.
- What restriction applies to vendor-specific layers in the Symbian system model?
- What is the purpose of the UI Framework Layer in the Symbian OS model?
π Lecture 12 β Symbian β Architecture
π Overview: This lecture provides a deep dive into the architectural design of the Symbian operating system, a seminal mobile OS. It explains the hierarchical system model, from components to packages, and details key design patterns, kernel architecture (EKA2), and the layered structure of the operating system. Understanding this architecture is crucial for grasping how early smartphones were designed for robustness, resource efficiency, and real-time performance.
ποΈ Topics Covered
This lecture covers the Symbian system model structure including technology domains, packages, collections, and components. It then explores Symbian design patterns such as the microkernel and client-server models, followed by a detailed look at Symbian packages, their internal levels, and the overall operating system architecture. Key features like the EKA2 kernel, application development options, and device statistics are also discussed.
π Lecture Summary
System Model Structure - Technology domains and packages
The Symbian system model is organized as a modular software stack. Layers are the fundamental stacking of software, where each layer abstracts the ones below. Levels within layers group packages by their intended audience. Packages are self-contained technologies, and levels within packages show their internal software stack. Collections are logical groupings of related components, and Components are the atomic unit of software architecture.
Symbian β Components
A component is the smallest architectural entity and is an implementation unit that provides a discrete, re-usable piece of the system. Each component includes build and packaging data such as binaries, data, tests, documentation, and source code. It also contains informative data for documentation or analysis, including its age, target devices (should, can, or must appear), intended target (device or desktop), and class of contents.
π Definition β Component: The smallest architectural entity of the system; an implementation unit that provides a discrete, re-usable piece of the system.
Symbian β Collections
A collection is a coherent set of collaborating components which together deliver a complete, discrete, and identifiable part of the systemβs functionality. Components in a collection are generally strongly coupled or implement the same interface (e.g., a family of plugins). A component with no strong ties in the package can live alone in its collection. Collections can group components to reflect the software or communication stack or a sub-technology of functionality. Collections are stacked in levels, with the primary package exposed interfaces on the top and the interface to lower layers or hardware on the bottom. Middle levels tend to reflect dependencies and technology-specific relationships.
π Definition β Collection: A coherent set of collaborating components which together deliver a complete, discrete, and identifiable part of the system functionality.
Symbian Design Patterns
Symbian OS utilizes several key design patterns: the microkernel pattern, the clientβserver pattern, Frameworks, the graphical application model, an event-based application model, specific idioms aimed at improving robustness, streams and stores for persistent data storage, and the class library. These patterns are fundamental to the OSβs structure and behavior.
Symbian β Architecture (Comm Services)
The OS Security package provides cryptography services to the layers above, including applications. This package contains several collections: the contentmgmt collection, the crypto collection, the cryptomgmtlibs collection, the cryptoservices collection, and securityanddataprivacytools.
Symbian β Packages
A package is a modular group of component collections that is sufficient to develop, build, and test a technology. Examples include high-level applications (Phone Apps), services with a common code base (Security Services), or a core technology (Graphics). Packages are the basic unit of Symbian Foundation organizational control, with their scope and model location agreed upon with the Foundation Architecture council. Each package is owned and maintained by a package owner (PkO) who has overall responsibility for its contents. A package belongs to a single technology domain, a vertical grouping of related packages. Packages can split or combine over time. Generic technologies split when they gain sufficient βmass,β while new technologies often start in generic packages (e.g., Generic App Support) to avoid overhead for technologies with an unclear future. For example, Device Services split out of Generic OS Services, and Shortlink Services split into Bluetooth and USB.
π Definition β Package: A modular group of component collections sufficient to develop, build, and test a technology, owned by a Package Owner (PkO) and belonging to a single technology domain.
Symbian β Architecture (Design)
Symbian OS was created with three systems design principles: the integrity and security of user data is paramount, user time must not be wasted, and all resources are scarce. It features pre-emptive multitasking and memory protection, follows an object-oriented Model-View-Controller (MVC) design, and has a strong emphasis on conserving resources through cleanup stacks, disk space, and low power modes. The system is event-based.
Symbian β Kernel
The Symbian kernel is responsible for bootstrapping the device, creating and managing fundamental abstractions like threads, processes, memory address spaces, and resources (timers, mutexes). It handles scheduling, pre-emption, interrupt handling, and provides access to devices via a device-driver framework. It encapsulates the kernelβuser boundary and the lowest level of an operating system port. EKA2 (EPOC Kernel Architecture 2) is the second-generation kernel. Its main features include Real-Time guarantees (time-bound API calls), multiple threads inside and outside the kernel, pluggable memory models for better ARM support, and a "nanokernel" providing the most basic OS facilities upon which other "personality layers" can be built. The kernel supports sufficiently-fast real-time response on a single processor core, employs a microkernel architecture containing only the most basic primitives for maximum robustness, availability, and responsiveness.
π‘ Why this matters: EKA2 was a major advancement, transforming Symbian from a non-real-time to a real-time OS, which was critical for its use in mobile phones with demanding performance needs.
π Definition β EKA2: The second-generation Symbian platform Kernel, offering real-time guarantees, pre-emptive multithreading, full memory protection, and a nanokernel design.
Symbian - Features
From 2010, Symbian switched to using standard C++ with Qt as the primary SDK. Alternative development could be done with Python (Python for S60), Adobe Flash, or JavaME. Earlier development used a Symbian-specific version of C++ along with the Carbide.c++ integrated development environment.
Symbian β Devices
As of 21 July 2009, more than 250 million devices running Symbian OS had been shipped. In addition to Nokia, Sony Ericsson and Samsung used Symbian OS.
Symbian β Packages (Internal Levels)
A packageβs internal software stack is described with levels. The lowest level provides an interface to hardware or layers below, the highest provides UIs, APIs, and documentation, while mid-levels tend to be frameworks, engines, servers, plugins, and internal tools. By convention, packages in the same layer and level have roughly the same number of internal levels. For example, at the OS Layer, hardware level has β€5 levels, with the bottom reserved for development boards. At the Application Layer, apps level has β€4 levels. Spanning packages have β€8 levels. Applications and UIs are on top, frameworks and engines below, and plugins and support on the bottom (guidelines, not binding).
Symbian β Architecture (Operating System Layers)
The All over Model contains the following layers, from top to bottom:
- UI Framework Layer
- Application Services Layer (including J2ME)
- OS Services Layer (including generic OS services, communications services, multimedia and graphics services, and connectivity services)
- Base Services Layer
- Kernel Services & Hardware Interface Layer
β Key Takeaways
The Symbian OS architecture is a layered, modular stack designed for resource-constrained, mobile environments. The system model is built from components (the smallest unit), which are grouped into collections, which are then grouped into packages, which are the unit of organizational control. The EKA2 kernel is a critical feature, introducing a nanokernel with real-time guarantees, pre-emptive multitasking, and full memory protection for robustness. The OS design is driven by three core principles: data integrity, user time efficiency, and resource scarcity, leading to features like cleanup stacks and an event-based model. Finally, the OS is structured into five main layers: UI Framework, Application Services, OS Services, Base Services, and Kernel Services & Hardware Interface.
π§ Quick Revision Questions
- What are the four hierarchical elements of the Symbian system model, from smallest to largest?
- What is a "collection" in Symbian, and what is its purpose in grouping components?
- What are the three core design principles upon which Symbian OS was created?
- What is the name of the second-generation Symbian kernel, and what major capability did it introduce?
- List the five layers of the Symbian operating system, from top to bottom.