In the Androird,
service is a none-UI background process that is doing some specific jobs.
6.1 Example Program : Understanding of Android Service.
6.2 Classification of Android Services
* Android Service
* System Service
* Java System Service
* Core Platform Service
* Hardware Service
* Native System Service
* Application Service
* Local Service
* Remote Service
6.3 Android Application Service
* It's one of the android application components.
* Usage
* Service start/end
: Start/End a service on the background.
* Remote control through binding
: If a service client binds to the service, the client can control
functions of the service through an interface provided by service
while the binding is maintained.
6.3.1 Separation of Application Service
※ The example of this chapter is in the API demos of Android 2.2.
* The application service is separated to local service and remote service.
A basis of this separation is whether an application and a service that is
created by application is in same process or separate.
* The local service ends when application ends. but the remote service
don't end though application ends.
* The difference between local service and remote service is the binding
way for the service control.
- Local Service
: Because the client program and service are on the same process, so
local service binding needs only reference of local service that is
bound by client.
- Remote Service
: For using a service, Activity must use IPC mechanism. In this case,
binder IPC is used. When it sends or receives between service and
activity in the binder IPC communication, it must go through
marshalling or unmarshalling, for this process it uses the AIDL.
※ AIDL(Android Interface Definition Language)
: On the android device, The AIDL is a IDL language for writing codes to
communicate between two prosesses.
(http://developer.android.com/guide/developing/tools/aidl.html)
A. Local Service
(1) Try to local binding through bindSercive() API.
* bindService(Intent, ServiceConnection, int)
- Intent
: An intent for local service.
- ServiceConnection
: On the service client side, it processes the binding connection
with service.
- int
: Context.BIND_AUTO_CREATE is a flag that creates a service
automatically, if there is not service to bind.
(2) For the binding processing, android calls the onBind() callback
method in service.
* the onBind() method returns a LocalBinder object that is extended for
connecting with activity and itself.
(3) Android framework calls the onServiceConnected(ComponentName,
IBinder) method in the side of service client.
* mBoundService = ((LocalService.LocalBinder)service).getService()
- The IBinder argument is returned from onBinder() method.
(4) Save a reference value of the LocalService into the mBoundService
member field in activity.
B. Remote Service
(1) Binding Activity : Requesting to connect with RemoteService
* Using the bindService() API for the control.
* The different part with local binding is in manifest file that
includes processing about com.example.android.apis.app.ISecondary
action.
(2) RemoteService Service : Implementing the Actual Service Method
Function and Providing the Binder Object for communicating with
Service.
* Main roles of the onBind() method is for creating the service binder
object for processing the binder IPC and returning it.
* The binder service object is created through the automatically
created ISecondary.stub class of ISecondary.java file. And when the
binder service object is created, implement the getPid() method(or
whatever) as the actual code.
(3) Binding Activity : Create the Proxy Object for Processing the Service
and the Binder IPC.
* When the onServiceConnected() call-back method of ServiceConnection
object is called, the second IBinder typed argument is passed to
ISecondary.Stub.asInterface() function. And then created and returned
ISecondary.Stub.Proxy proxy service object is saved into
mSecondaryService member variable.
* It's the end of binding process. And after this process, a activity
can call methods of RemoteService like it owns them.
(4) Binding Activity : Through the Using of Proxy Object, Call The
Service Proxy Method in the Remote Service.
(5) Binder IPC : Pass the Binder IPC Data from the Service Proxy Object
to Service Binder Object.
(6) RemoteService Service : Call the Stub Method of RemoteService
Service.
※ The Creation Classification of Local Service With Remote Service.
* The answer is in the manifest file. All of the android services must be
represented to elements in the manifest file.
A. Local Service
: Only of names of that can be implemented service from class are written
in the "android:name" attribute.
B. Remote Service
: In addition to local service, remote service is using the
"android:process" attribute in the manifest file. If there is not the
attribute, that service will perform as a local service.
6.4 Android System Service
* Android system services are in the application framework layer and
libraries layer.
6.4.1 Classification of System Service
(1) Native System Service
* Representatively, audio flinger service and surface flinger service are
exist.
(2) Java System Service
A. Core Platform Service
B. Hardware Service
6.5 Running the System Service
* Can use the system service directly with getSystemService()
method.
Because, the system service is launched by init process on the booting
process.
* The system service is started by the media server and the system server.
- The media server process
: Execute the native services like audio server or media player server.
- The system server process
: This process is on the java based, and created first by Zygote.
: Execute native system services like the surface flinger and etc.
* Creation Process on the Android System Booting
(1) Start the Media Server Processes.
(2) Start the Zygote.
(3) Start the System Server.
(4) Start the Surface Flinger Services.
(5) Start the Java System Services.
6.5.1 Media Server Execution Code Analysis
(1) Start from Init Process.
* It makes the native services(Audio Flinger, Media Player Service,
Camera Service, Audio Policy Service, etc) started by
the media server.
(2) Create and Initialize the Native Service Instance.
* Do this in the main function of media server.
(3) Look up the Initializing Code in Each System Services.
* Using binder IPC.
* Service provider like system service have to register information to
manifest manager.
* Each initializing codes are shaped of same form. just using new and
addService() each services' functions to context manager.
* defaultServiceManager() function returns an object, service manager is
sort of proxy object doing binder communication with the context
manager.
* It has simple mechanism. Just create each instance of service, and
register to context manager.
6.5.2 Analysis of Running Code of Server
(1) Created by Zygote.
(2) Load android_servers library.
* In the main() method of SystemServer class, system_init() JNI function
is called by the init1() method. Because, SystemServer is a Java
process. So can't call the c++ based custom service.
* After start a service, call the callStatic() function to call the
init2() method.
(3) Initialize and Register the Java System Service.
* In the init2() method, Create and run the ServerThread that creates all
of the Java system service.
* Register to ContextManager as like native system services, but use the
addService() static method in the ServiceManager class.
|