Any support higher level functionality. A C library

Published by admin on

Any computer Operating System (OS) is
software that manages various resources which are available to that computer. CPU, RAM, memory, printers, displays, etc. are all
resources that require specific controls to allow smooth and efficient
operation of any computer and users interacting with it. There is no single
Operating System, but instead many ranging a variety of different devices and
hardware. Android is an open source OS targeting mobile devices and is based on
the Linux kernel which was chosen for its proven track record and multi-tasking

Although Android’s core is
Linux, Android has a limited set of software and libraries that aren’t available
on a typical Linux distribution. While based on Linux you would not be able to
run applications built for various Linux distributions (e.g. Ubuntu, Debian, Fedora etc.) on Android devices. Android
uses the Linux kernel as a base from which to build which has a proven model
with existing drivers including but not limited to memory, networking and
process management. With that said, the standard Linux Kernel was modified to
support the special needs of mobile devices. 
Such enhancements included alarm driver, Android shared memory driver,
binder driver (for Inter-Process Communication), power management, low memory management,
and a kernel debugger / logger. In addition to the standard capabilities and
enhancements provided by the Linux Kernel, Android needs additional libraries
to support higher level functionality. A C library and well as a Java Runtime were
created and optimized to run on what was called the Dalvik Virtual Machine, which
was part of the Android stack in versions 4.4 or earlier. The Dalvik VM used a Just-In-Time approach where
compilation of what are called .dex files (i.e. a distinct Android format called
Dalvik) into byte code is done on demand. This is similar in some ways to what
is done in Java environment where .class files are created; and converted into
byte code usable in Java. In an Android environment .class file(s) are created and
converted into a single .dex which is a Dalvik executable. Due to slow performance
characteristics of a on demand compilation approach his has
since been replaced by the Android Runtime (ART) with an eye toward performance
improvements. ART uses an Ahead-Of-Time approach
where .dex files are compiled before they are needed. This gives a large boost
in performance and well as helping with battery life. In practice when using a
DVM approach when you open an app, files get converted to their native code and
will only start working when the compilation is completed; until then the app won’t
respond. Using an ART approach files are converted once and your done. Although
this takes some initial time and additional storage performance is improved as
is battery life. 4 10 11   

that Android is open-source, developers can build application functionality to
suit the requirements of any specific mobile device and specifications of the
carriers that market these devices. Although different devices may be running
the same version of Android, modifications can provide a custom look and feel
based on carrier preferences. To that end, the Android Open Source Project was
created and continues to be led by Google. Innovation is encouraged; however,
to ensure integrity an “Android Compatibility Program” was created to guide
developers to achieve “Android Compatible” builds. Although applications must
be “minimalistic” (i.e. lightweight) they still must have the ability to
address local broadband connectivity, smaller form factors, and the
requirements of different marketers of these devices whom give it a specific
“flavor” of that brand.

We Will Write a Custom Essay Specifically
For You For Only $13.90/page!

order now

There are
specific issues that come with the development of mobile applications. One
obvious issue with mobile devices is the mobility of the device itself. For
example, using magnetic data storage with moving parts, a large size and
relatively slow data access was not feasible. Using flash memory which had a
small footprint, and eliminated moving parts provided stability fast access
speeds. To achieve this Android originally used a file system known as “Yet
Another Flash File System” (YAFFA). This had fast read time, and was resistant
to the physical movement of a mobile device. As technology advanced, Android
switched to EXT4 (Extended File System) to take advantage newer of dual core
processors allowing for multi-threading, as opposed to YAFFA which was
single-threaded and likely to cause bottlenecks in devices with faster
processors. 4 9 Another issue was not related to the physical
nature of the device but one which has significant implications: the security
of the Android OS. Earlier versions of Android had very limited security capabilities,
however, starting with Froyo version 2.2 additional security features became
part of the OS; password policies, and remote lock / wipe to start with. As new
versions were released so were updated security features: encryption/crypto
API’s, certificate management, secure developer interfaces (i.e. SSL), and facial
unlock. As with any security measure intended to protect a user’s device, while
these new features become available, the specific implementation of said
measure will determine how secure a device will be. For example, if a
capability exists to define password policies, but an administrator defines
weak policies, the device may be vulnerable to certain types of attacks. 5

Device security was a main concern of Google, and as a result
of an inevitable effort to keep the user’s data secure, Google created an “Android
Security Program” which consists of several components; design review, penetration testing, code
review, open source and community review as well as incident response and monthly
security updates. These process oriented mechanisms help to deliver secure
code; however, Android also uses capabilities derived from the Linux Kernel. These include but are
not limited to user-based permissions, isolation
of processes, secure inter-process communication and the ability to remove
unnecessary and potentially insecure parts of the Kernel. Given Linux is a
multi-user operating system a main security objective within the Kernel is to isolate user resources from one

Android uses this capability to isolate application resources. Android uses a unique
ID assigned to each application which runs as a separate process with distinct
permissions. This is the basis for the application sandbox. This is in contrast
to Linux which may run multiple applications with the same permissions. The
Linux kernel enforces security (i.e. ID’s assigned to an application cannot
interact with other applications or gain access to data). Since the Sandbox is
effectively in the Kernel this model extends not only to application code but OS
applications as well. All applications above the Kernel (see appendix A) will
run within the application Sandbox. This greatly enhances the protections
within the context of the Android environment. As an example, a fairly common
problem such as memory corruption could lead to issues with applications that
run within the same memory space. Such issues are limited within the context of
the Android environment, given the isolation mechanisms derived from the Linux
Kernel. The OS level Sandboxing will only allow impacts in the context of that
particular application thus shielding others from potential flaws. 6 8

Starting with version
4.3, the Android security model uses SELinux (Security Enhanced Linux in
Android). This enforces mandatory access control (MAC) over all processes including
root, which confines privileged processes and automates security policy. The
Android Open Source community has contributed to SELinux which has of course been
made publicly available. As part of SELinux, Android can be set up in
“enforcing mode” which means permissions denials are both logged and enforced. Violations are
logged by the kernel to dmesg
(messages produced by device drivers) and logcat
(dumps a log of system messages), which allows device manufacturers to review
and refine their software to determine what policies should and should not be
enforced. (Note I may put more
stuff here)

Android has considerable flexibility.

This flexibility can be thought of as an advantage to the development
community; however, such flexibility can also be its weakness. As an example,
there are three types of Android devices on the market: Google Lead, Google
Experience and “Other” devices. Google Lead Devices and basically 100% Android
with no OEM or Carrier customizations, Google Experience devices are CTS
(Compatibility Test Suite) compliant which means they pass specific criteria of
testing for that version of Android, they have some carrier customization and
support critical patches to WiFi security flaws (Google Promise). Other are
devices are not CTS compliant and have significant carrier modifications. As
such although these implementations are all Android they are not created equal.


Categories: Management


I'm Iren!

Would you like to get a custom essay? How about receiving a customized one?

Check it out