Android Service Summary

 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.