Professional Documents
Culture Documents
INTRODUCTION:
All the elements of the user interface in an Android app are built using
View and ViewGroup objects. A View is an object that draws something on
the screen that the user can interact with. A ViewGroup is an object that
holds other View (and ViewGroup) objects in order to define the layout of the
interface. Each component of any applications user interface is defined
using a hierarchy of View and ViewGroup objects. Every application on
Android is assigned a different Linux user ID. This separates applications
from each other and prevents them from reading data they are not supposed
to be reading.
To declare any layout, the designer can instantiate View objects in code
and start building a tree. The easiest and most effective way to define any
layout is with an XML file. XML offers a human-readable structure for the
layout, similar to HTML. The designer does not have to build all UI
using View and ViewGroup objects. Android provides several app components
that offer a standard UI layout for which you simply need to define the
content. These UI components each have a unique set of APIs that are
described in their respective documents, such as Adding the App
Bar, Dialogs, and Status Notifications.
The User Interface has been through great deal of changes with every
Android update. Since April 2009's Android 1.5 "Cupcake", Android versions
have had confectionery-themed code names, starting with the first
commercial version Cupcake, Donut, Eclair, Froyo, Gingerbread, Honeycomb,
etc.
PROCESSOR AND PROCESSES:
The main processors used in Android powered devices are ARM and
Qualcomm. Qualcomm leads in Android phone implementation with the
Snapdragon SoC (System-on-Chip). Snapdragon includes an ARM
compatible CPU core of its own design called the Krait. Phones ARM chip
plays a key role in application performance and battery life. Along with this,
Krait is Qualcomms Adreno graphics technology.
A process life cycle on Android can be divided into five different states,
from most important to least important.
1. Foreground: A foreground process is the application currently being
used. It is also the most important process. The OS may resort to killing
other processes just to keep a foreground process alive.
2. Visible: A visible process is not the foreground process, but it is doing
some calculations that the user has requested.
3. Service: A service process is not associated with any specific visible
process. However, it is working on something in the background (e.g.
downloading or uploading something).
4. Background: A background process is not currently visible to the user.
These processes have no impact on performance.
5. Empty: An empty process does not contain any app data any longer. It
might be kept in for caching or removed depending on the systems
requirements.
Most of the time the OS does these managements without the user
involvement. Android intelligently uses the RAM for cached and application
data, since there is no point in leaving the devices RAM empty.
On the other hand, Android provides so much room and flexibility for a
poorly coded application to misbehave. For instance, an application can start
a service process that stays running in the background all the time, using
device resources and declining its performance.
The Zygote process starts when the system boots up and loads
common framework and resources. When a new application starts, the
OS forks the zygote then loads and runs the applications code in the
new process. This allows most of the RAM pages to be shared among
application processes.
Most static data is mmapped into a process. This technique allows data
to be shared between processes, and also allows it to be paged out
when needed.
FILE SYSTEM:
Android allows its users to view all kinds of files present on the device
through different applications. This also counts as one of the advantages
over iOS. Androids file system is different, here is how its divided:
Device Storage: This is the area of storage the user is free to access
and modify any file. This section includes number of folders created by
Android. Some of these are used by installed applications for their
cache files.
Other folders are designed to store personal files in an organized
manner, but the user can modify or delete them as necessary.
DCIM: Photos taken by the user are stored here. Image Viewers
or Gallery displays photos present in this folder.
Download: Any file downloaded by the user is saved here. This
file could be of any type, i.e. mp3, mp4, exe, apk, etc. The user is
free to move or delete any file.
Ringtones, Pictures, Music, Movies and Videos: These folders are
designated to store personal media, however the user is free to
store them elsewhere.
Portable SD Card: Almost all Android devices support SD Cards. The
user can plug the SD Card onto their computers or other devices, load
files or folders onto it and then plug the SD Card into their Android
device. The SD Card is versatile and can include any kind of data,
media, execution files, etc.
Device Root: Every Android device has a special section called the
Root, where the operating system files, installed application, and
sensitive data is stored. Most file managers cannot modify the system
files for security reasons. Changes can be made only if the user or the
specific application (File Manager) has root access.
CUSTOM ROMS:
On the other hand, the user has to understand that modifying a ROM
with basic set of instructions is not easy and requires a lot of work. Custom
ROMs could also void the devices warranty as only some manufacturers
tolerate changes to the device system.
CONCLUSION:
Android was founded in 2003 by Andy Rubin, Rich Miner, Nick Sears,
and Chris White. The founders had strong ties to T-Mobile. Also, T-Mobile
landed the first Android phone (HTC Dream). User Interface enhancements
have been one of the top priorities of Android. Every version along with
performance updates had great UI changes. Android uses Qualcomms
Snapdragon SoC integrated with Adreno graphics. Snapdragon 800 series
runs up to 2.46 Ghz with Adreno 330. Process management is simple as it
works with least recently used (LRU) algorithm. Android Runtime (ART) uses
mmapping and paging for memory management. The generational heap
promotes process based on their object generations. Unused memory is
reclaimed by garbage collection events. The memory is divided and well
organized into Device storage, SD card and Device root. Android allows its
users flexibility over organization and modification of stored data. It uses
different protocols to transfer files such as PTP and MTP. Also supports
wireless transfers. One of the major features of Android being open source is
it allows designer to make changes under the flexible AOSP.
The two authors of this paper use Android devices (Nexus 6P and
Samsung Galaxy A5). We support Android, because unlike iOS, Android OS is
open-source meaning that anyone can read, modify, and improve its code. If
Android was closed-source, writing this paper would have been very difficult
if not impossible.
REFERENCES:
https://en.wikipedia.org/wiki/Android_(operating_system)
https://en.wikipedia.org/wiki/Android_version_history
https://developer.android.com/topic/performance/memory-
overview.html#AllocatingRAM
https://en.wikipedia.org/wiki/Memory-mapped_file
http://www.howtogeek.com/202644/how-to-manage-files-and-use-the-
file-system-on-android/
https://www.androidpit.com/best-custom-roms-for-android
http://phandroid.com/2015/02/05/10-surprising-android-facts/