Build the right UI for your complex embedded system
Finally, the design and implementation techniques employed at the application level offer limited opportunities to add vendor customization without excessive programming effort. This is a capability demanded by service providers for wireless networks or cable TV operators, for example. These companies view the phone or set-top box as a differentiating extension of the unique service they provide and want to reinforce this message at every opportunity.
The good news is that all three challenges can be addressed by taking a different approach to UI development.
The way to create a UI for a complex embedded system is to implement it as a separate software layer, which may be hooked into all the device's application components. Figure 1 shows a system block diagram illustrating how such a UI engine might work. In this context, the software provides the display graphics and user interaction control. The developer simply configures the UI using XML.
The advantage to the developer when using a UI engine is the simplicity of the methods involved in creating a sophisticated, attractive UI. Once all interface behavior has been delegated to the engine, many aspects of the UI's design (including its branding, look and feel, and menu structure) may be configured with small parametric adjustments that require no coding or scripting. Simple declarative XML files, which are both extensible and human readable, provide an ideal way to specify such a parameterization.
Declarative XML
This more rationalized approach to UI development treats each UI menu as a well-defined state machine. A developer need only define what states are permissible, how each onscreen element should look in each state, and what interaction events (such as key presses or stylus taps) should trigger changes from one state to another. The UI engine implements all the logic required to morph the UI's appearance whenever a state change occurs, for example, by scrolling a series of items by one position, or by switching the active focus from one item to another, when a particular key is pressed.
By automating such UI logic, much of the complexity of constructing sophisticated new interfaces is avoided. The substance of the task can be reduced to describing the UI as a series of visual snapshots (or layouts), each representing a single permissible state. Each layout merely defines how every onscreen element should appear (be it text, bitmap, or other visual content) when the UI is in the corresponding state. This definition requires no conditional branching, looping, or programming construct of any kind. In fact, completely new UI designs can be constructed using simple declarative XML formats.
Even more sophisticated UI layouts are possible with this type of platform approach because the visual appearance of any onscreen element (such as an individual icon or caption) can be controlled to a high degree.
Loading comments... Write a comment