- Services are components that run in the background to perform long-running operations or interact with content providers. There are three main types: foreground, background, and bound services. - The lifecycle of a service includes methods like onStartCommand(), onBind(), onUnbind(), and onDestroy(). Services can be either started or bound. - The Android architecture consists of layers including the Linux kernel, libraries, the Android framework, and applications. The Dalvik VM executes compiled applications.

1. Data Transfer between
Activities & Databases
Faiz Ur Rehman

2. Services
• Android services a component that issued to perform operations on
the background such as playing music, handle network transactions,
interacting content providers etc. It doesn't has any UI (user
interface).
• The service runs in the background indefinitely even if application is
destroyed.
•three different types of services

3. • 1. Foreground-A foreground service performs some operation that is
noticeable to the user. Start Service()
• 2. Background-A background service performs an operation that isn't
directly noticed by the user. Start Service()
• 3. Bound-A service is bound when an application component binds to it by
calling bindService(). A bound service offers a client-server interface that
allows components to interact with the service, send requests, receive
results, and even do so across processes with inter process communication
(IPC). A bound service runs only as long as another application component
is bound to it. Multiple components can bind to the service at once, but
when all of them unbind, the service is destroyed.

4. Lifecycle
A service can essentially take two states −
• Started A service is started when an application component, such as
an activity, starts it by calling startService(). Once started, a service
can run in the background indefinitely, even if the component that
started it is destroyed.
• Bound A service is bound when an application component binds to it
by calling bindService(). A bound service offers a client-server
interface that allows components to interact with the service, send
requests, get results, and even do so across processes with inter
process communication (IPC).

6. • Create a Service Generally, in android to create a service we must
create a subclass of Service. In android the application component
such as an activity can start the service by calling startService()which
results in calling the service’s on StartCommand()method
• onCreate() The system calls this method when the service is first
created using on StartCommand() or onBind(). This call is required to
perform one-time set-up.

7. • onStartCommand()
The system calls this method when another component, such as an
activity, requests that the service be started, by calling startService(). If
you implement this method, it is your responsibility to stop the service
when its work is done, by callingstopSelf() or stopService()methods

8. • onBind()
The system calls this method when another component wants to bind
with the service by calling bindService(). If you implement this method,
you must provide an interface that clients use to communicate with the
service, by returning an iBinderobject. You must always implement this
method, but if you don't want to allow binding, then you should return
null

9. • onUnbind() The system calls this method when all clients have
disconnected from a particular interface published by the service.
•onRebind() The system calls this method when new clients have
connected to the service, after it had previously been notified that all
had disconnected in its onUnbind(Intent).
••onDestroy() The system calls this method when the service is no
longer used and is being destroyed. Your service should implement this
to clean up any resources such as threads, registered listeners,
receivers, etc.

10. Watch Video
• https://www.youtube.com/watch?v=PUxC6vzEEgg

11. Android Architecture
• Android operating system is a stack of software components which is
roughly divided into five sections and four main layers as shown
below in the architecture diagram.

13. Layer 1
• Linux kernel
• At the bottom of the layers is Linux -Linux 3.6 with approximately 115
patches. This provides a level of abstraction between the device
hardware and it contains all the essential hardware drivers like
camera, keypad, display etc. Also, the kernel handles all the things
that Linux is really good at such as networking and a vast array of
device drivers, which take the pain out of interfacing to peripheral
hardware.

14. • Linux Kernel has three main parts.
Device Driver
Memory Management
Process Management

15. Libraries
C/C++
Interface
through Java
Surface Manager
Handling UI
Windows
2D/3D
SQLite and
Browser Engine

16. • On top of Linux kernel there is a set of libraries including open-
source Web browser engine WebKit, well known library libc, SQLite
database which is a useful repository for storage and sharing of
application data, libraries to play and record audio and video, SSL
libraries responsible for Internet security etc

17. Android Libraries
• This category encompasses those Java-based libraries that are specific
to Android development. Examples of libraries in this category include
the application framework libraries in addition to those that facilitate
user interface building, graphics drawing and database access.
• A summary of some key core Android libraries available to the
Android developer is as follows

18. • Android.app : Provides access to the application model and is the
cornerstone of all Android applications.
•Android.content− Facilitates content access, publishing and messaging
between applications and application components.
•Android.database− Used to access data published by content providers and
includes SQLite database management classes.
•android.opengl− A Java interface to the OpenGL ES 3Dgraphics rendering
API.
•android.os− Provides applications with access to standard operating
system services including messages, system services and inter-process
communication

19. • Android.Text− Used to render and manipulate text on a device display.
• Android.view− The fundamental building blocks of application user
interfaces.
• Android.widget− A rich collection of pre-built user interface
components such as buttons, labels, list views, layout managers, radio
buttons etc.
• Android.webkit− A set of classes intended to allow web-browsing
capabilities to be built into applications

20. Application Framework
• The Application Framework layer provides many higher-level services
to applications in the form of Java classes. Application developers
are allowed to make use of these services in their applications.

21. • The Android framework includes the following key services
•Activity Manager− Controls all aspects of the application lifecycle and
activity stack.
•Content Providers− Allows applications to publish and share data with
other applications.
•Resource Manager− Provides access to non-code embedded resources such
as strings, color settings and user interface layouts.
•Notifications Manager− Allows applications to display alerts and
notifications to the user.
•View System− An extensible set of views used to create application user
interfaces.

22. Applications
• Browser
• Bluetooth
• Animation

23. Android Runtime
1. Dalvik VM
Dex files
Compact and efficient than class files
Limited Memory and battery power
2. Core Libaries
Java 5 Std edition
Collection, I/O devices

24. • The Dalvik Virtual Machine (DVM) is an android virtual machine
optimized for mobile devices. It optimizes the virtual machine
for memory, battery life and performance.
• Dalvik is a name of a town in Iceland. The Dalvik VM was written by
Dan Bornstein.
• The Dex compiler converts the class files into the .dex file that run on
the Dalvik VM. Multiple class files are converted into one dex file.

26. • END