5 - Applications BB

1. IT-4545
Mobile Computing
Ch#3: Applications
Slides conceived from: Programming Mobile Devices: An Introduction for Practitioners Tommi Mikkonen
2007 John Wiley & Sons, Ltd

2. What Constitutes an Application?
•Transformators that translate a given input to a
corresponding output
•At microscale, rapidly reacting to smallish changes
in their environment
•Changes can take place in parallel
•Become reactive systems
•Become more complex entities

3. What Constitutes an Application?
•Definition “it is a piece of software that can be
started and terminated individually, and that it
performs a certain task”.
•The term ‘application’ includes the necessary user
interfaces and related facilities
•Software as an application need to have interface
mechanism for execution platform
•For instance, in C/C++ function main, from which
the execution of the application begins
•Platforms define a specific way to link applications
to the surrounding infrastructure

4. What Constitutes an Application?
•How the application is to be used is the depth of its
integration to the rest of the system?
•Following cases can be identified:
- Application is independent of the rest of the system. Such
types of applications are self-contained, and for the most
part, they simply rely on the platform’s low-level services.
- Applications share library code. In principle, this in fact
takes place when the platform provides services to new
applications. However, the more application specific the
library is, the more effort must be invested in keeping
applications compatible with each other when the library
version is altered.

5. What Constitutes an Application?
- Application directly shares data with some other
application. For instance, one can compose a personal
information management and planning center application
that collects all the data from contacts, todo list, calendar,
and so forth. Then, when updates are made via one
application, the data should be made available for other
applications as well. As a result, applications are
becoming tangled.
- Applications can be embedded in each other. For
instance, when sending a multimedia message, it may be
possible to run a camera application invisibly to the user
to record the data to be sent.

6. Workflow for Application
Development
•Consistency of user experience
•Aspect can be affected by a number of design
choices
•Resulting in consistent usability
•Actions must be simple and single yet focused

7. Workflow for Application
Development
•A common workflow with special focus on usability
and user activities, has been defined by Salmre
(2005), consisting of:
- Scoping
- Performance considerations
- User interface design
- Data model and memory concerns
- Communications and I/O

8. Workflow for Application
Development
•Scoping
- what the application can do and what it cannot
- Scoping can be helped by conceptualizing the application
with pictures, mockups, and creating prototypes.
- One should also consider the relative importance of the
functions to users
- For instance, if clock times are rarely entered
•Performance Considerations
- General responsiveness metrics are needed for
applications
- How fast it should be to open a menu in the application
- Use an older (or simply less capable) hardware for early
experiments

9. Workflow for Application
Development
- All assumptions should be tested with a real
implementation
- Overall performance is often the most important aspect
- Then, data structures, memory layouts, algorithms, and
the way the user interface is constructed
- One should also consider that overly focusing on
performance can be harmful for portability
•User Interface Design
- If the performance provided enough then focus on the
right user interface
- End-user productivity and responsiveness as the most
important principles
• Productivity - actions for the end-user can be easily and rapidly
carried out
• Responsiveness - feeling of being in control while performing the
activities

10. Workflow for Application
Development
- User is never left wondering what the device is actually
doing
- For example, the phone claims to be ready after a reboot
even if it has not yet loaded contacts from SIM
- Keep the user aware of what has really been saved to
disk, if the user wishes to turn off the device
- Consider available facilities
- For instance, it seems completely realistic to edit Excel
macros when using a Communicator type of device, but
being able to read the figures might be enough in a
normal mobile phone where more restricted resources
are available
- Consider whether to aim at special-purpose devices and
applications or to a single tool that does everything

11. Workflow for Application
Development
•Data Model and Memory Concerns
- Mobile devices offer rather restricted facilities for
application development
- Concerns are how data can be located in the memory,
how the system behaves in peak conditions, and how the
application disposes data
- Data structures and memory use in general must be
carefully considered.
- Also dynamically loaded libraries can be considered as
an issue that is closely related to data model and memory
concerns

12. Workflow for Application
Development
•Communications and I/O
- Communications and I/O are defined determines how the
application communicates with the resources
- Devices’ internal resources, such as files and
subsystems, as well as resources that are external to the
device
- For instance, socket-based communications, files on
servers, Web Services, and remote databases
- Another important aspect is the level of abstraction of
transmitted and stored data. For example, one can
consider the following levels of abstraction in using files:
• Binary streams, where the data is stored in a fashion that is
unreadable without auxiliary software,
• Text streams, where data becomes more readable, but may
still remain somewhat unstructured and unreadable for a
human reader,
• XML forward-only readers and writers, where more meta-
information is included,
• XML Document Object Model, where complex automatic
processing of included data is usually enabled

13. Techniques for Composing
Applications
•Event-Based Programming
- GUI element to generate events
- For instance, cursor moves over a button, a button click
- Callbacks are used to link events and code
- One can register an operation that is called when a
certain event occurs, like a key press
- Implementing a callback
• One is to pass a reference to a function during registration. When an
event occurs, the function is called via the reference
• Follow the Observer design pattern
- Fundamental difference between event-based
programming and the traditional programming approach
• in the traditional approach, the service caller knows the provider of the
service,
• in the event-driven model, the event source only creates the event, and it
is up to the components that have registered themselves to handle the
event to perform their actions

14. Techniques for Composing
Applications: MVC
•Model-View-Controller as the Application
Architecture
- presentation-abstraction-control (PAC) pattern is similar
to MVC for the mobile environment
- MVC model is to separate all the functions of the
application to one of the following three categories
• Model, which contains data structures of the application.
• Views, which contain user interface(s) of the application.
• Controllers, which allow the user to control the behavior of the
application.

15. Techniques for Composing
Applications: MVC

16. Techniques for Composing
Applications: MVC

17. Techniques for Composing
Applications: MVC
•Model
- The model is to host all the information regarding the
data of the application
- All operations regarding the data are included
- Model is also usually responsible for managing data
representation in permanent memory
- Whenever the data is manipulated, the model informs
views and controllers about the change
- Models remain relatively independent of all user interface
operations, they can usually be reused in different
environments.

18. Techniques for Composing
Applications: MVC
•View
- display data to the user
- Whenever a model is updated, the views that are
registered to observe the model are notified about the
update
- Query information about the update and display the
upgraded data
•Controller
- Controller listens to the commands the application
receives and translates them into a form that can be
interpreted by the model
- Sometimes views and controllers can be integrated, if
their operations are closely coupled

19. Techniques for Composing
Applications: Auxiliary Files
•Resources and other auxiliary files that are
commonly needed by applications
•Such as, application connected with graphics to
improve look and feel
•Considerable factor of memory consumption of a
mobile application
•Menus.
- In many environments, resource files can be used to
define the structure of menus that are offered by
applications.
- The rationale is that in order to modify menus, application
code need not be modified, but it is enough to redefine
some
elements in the auxiliary file.

20. Techniques for Composing
Applications: Auxiliary Files
•Binary data.
- graphics, such as icons, are used for creating a special
look for applications
- Various formats that can be used in general, different
platforms may have some restrictions on their use in
different contexts.
- Connecting graphics to program behavior can take a
similar form as with menus
- Similarly to graphics, other types of binary data can be
used as well
- For instance sounds and audio data

21. Techniques for Composing
Applications: Auxiliary Files
•Localization information.
- Such information includes definitions needed for multiple
language versions
- They can be given together with other resources, but this
is not a necessity
- Instead, any file can be used for aiding in localization,
assuming that the rest of the program is composed
respecting the localization principles
- However, when the underlying platform offers its own
practices for this, the platform’s fashion should be
predominantly used

22. Techniques for Composing
Applications: Auxiliary Files
•Other auxiliary files.
- Auxiliary files needed by applications are many.
- For instance, there can be data files whose contents are
needed for creating a valid initial state.
- Usually, one should compose applications so that even if
some of the data files are missing, it would be possible to
run the application.
- A related issue is that in some systems, it is advisable to
implement applications such that they always have a
default data file into which data can be saved if no
filename is given for saving it.
- In addition to data files, there can be settings or profile
files.
- Again, it is commonly a good design goal to be able to
run the application with minimal or even with fully missing
settings files.

23. Techniques for Composing Applications:
Managing Applications
•A number of management operations can be
associated with applications running in mobile
devices. For instance,
•Retrieval.
- Applications can be retrieved from some location in the
network or some other media.
- For instance, physical media such as memory cards can
be used.
- However, for wireless devices, downloading applications
over the air (OTA) is probably the most prominent
alternative.

24. Techniques for Composing Applications:
Managing Applications
•Installation.
- Installs an application to a device.
- The installation may include several intermediate steps
- Such as verification that the installation is allowed and
transformation, where the downloaded software can be
transformed to a suitable execution format.
•Launching.
- The application must obviously be startable once it has
been downloaded and installed in the device

25. Techniques for Composing Applications:
Managing Applications
•Version management.
- It may be necessary to upgrade already installed
applications when new versions are released.
- It is also possible that upgrading one version of a
subsystem (or application) requires an upgrade of other
parts of the system as well.
•Removal.
- Applications can be removed from the device when they
are no longer needed, or the storage space occupied by
them is needed for some other use

26. Techniques for Composing
Applications: Practicalities
•Different platforms reflect the different origins and
intentions, which leads to different characteristics.
•As a result, they are suited for accomplishing
different things. Moreover, the size of the step to
compose the first application in a certain
environment can vary considerably.
•For example, with mobile Java, as we will soon
study, it is natural to start with only a single class
and start extending the application.
•Symbian OS, on the other hand, shows signs of a
system that has been targeted for more complex
systems, where an established design has been
composed before advancing to coding.