Android开发之低调的Service

锲而舍之，朽木不折；锲而不舍，金石可镂。——荀况

    今天学习了一下Service的用法就和大家一起来讨论Android中Service的相关知识点，如有谬误，欢迎批评指正，如有疑问欢迎留言。

一、Service用途

     Service在Android中和Activity是属于同一级别上的组件，Android中的Service，其意思是“服务”，它在后台运行不可交互。Service自己不能运行，需要通过某一个Activity或者其它Context对象来调用，Context.startService()和Context.bindService()两种方式启动 Service 。 Service在Android中和Activity是属于同一级别上的组件，Android 中的Service ，其意思是“服务”，它是在后台运行，不可交互的。Service自己不能运行，需要通过某一个Activity或者其它Context对象来调用，Context.startService()和Context.bindService()两种方式启动 Service 。
       Android 中的服务，它与 Activity不同，它是不能与用户交互的,不能自己启动的，运行在后台的程序(干着重的工作，却连个界面也没有，因此我说它低调)，如果我们退出应用时， Service进程并没有结束，它仍然在后台运行，那我们什么时候会用到Service呢？比如我们播放音乐的时候，有可能想边听音乐边干些其他事情，当我们退出播放音乐的应用，如果不用 Service，我们就听不到歌了，所以这时候就得用到Service了，又比如当我们一个应用的数据是通过网络获取的，不同时间（一段时间）的数据是不同的，这时候我们可以用 Service在后台定时更新，而不用每打开应用的时候在去获取。如果在 Service的 onCreate或者 onStart方法中做一些很耗时的动作，最好是启动一个新线程来运行这个 Service，因为，如果 Service运行在主线程中，会影响到程序的 UI操作或者阻塞主线程中的其它事情。 

二、Service的生命周期

首先来看官网给出的Service的生命周期图

package com.example.servicepractice;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service {
     
     private static final String TAG = "MyService";

     @Override
     public void onCreate() {
            super.onCreate();
           Log. i(TAG,"onCreate called" );
     }
     
     @Override
     public void onStart(Intent intent, int startId) {
            super. onStart(intent, startId);
           Log. i(TAG,"onStart called" );
     }
     
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
           Log. i(TAG,"onStartCommand called" );
            return super.onStartCommand(intent, flags, startId);
     }
     
     @Override
     public void onDestroy() {
            super.onDestroy();
           Log. i(TAG,"onDestroy called" );
     }
     
     @Override
     public IBinder onBind(Intent intent) {
           Log. i(TAG,"onBind called" );
            return null;
     }
     
     @Override
     public boolean onUnbind(Intent intent) {
           Log. i(TAG,"onUnbind called" );
            return super.onUnbind(intent);
     }
}

package com.example.servicepractice;

import android.os.Bundle;
import android.os.IBinder;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup.LayoutParams;
import android.widget.Button;

public class MainActivity extends Activity {
     
     protected static final String TAG = "MyService";
     
     private Button btn_start;
     private Button btn_stop;

     private Button btn_bind;
     private Button btn_unbind;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
           setContentView(R.layout. activity_main);
     
           findViews();
           
           setClick();
     }


     private void findViews() {
            btn_start=(Button) findViewById(R.id. btn_start);
            btn_stop=(Button) findViewById(R.id. btn_stop);
           
            btn_bind=(Button) findViewById(R.id. btn_bind);
            btn_unbind=(Button) findViewById(R.id. btn_unbind);
           
     }
     
     private void setClick() {
            //采用startService启动服务
            btn_start.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     Intent intent= new Intent(MainActivity.this,MyService.class );
                     startService(intent);
                }
           });
            //销毁服务
            btn_stop.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     Intent intent= new Intent(MainActivity.this,MyService.class );
                     stopService(intent);
                }
           });
            //绑定服务
            btn_bind.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     Intent intent = new Intent(MainActivity.this,MyService.class );
                     bindService(intent, conn,Context. BIND_AUTO_CREATE);
                }
           });
            //解除绑定
            btn_unbind.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     unbindService( conn);
                }
           });
     }
     
  private ServiceConnection conn=new ServiceConnection() {
      
       public void onServiceConnected(ComponentName name, IBinder service) {
                 //connected
                Log. i(TAG,"onServiceConnection called." );
           }
     
     public void onServiceDisconnected(ComponentName name) {
           
           
     } 
 };   
}

   <service
         android:name="com.example.servicepractice.MyService" >
         <intent-filter>
                <action android:name="com.example.service" />
                <category android:name="android.intent.category.DEFAULT" />
         </intent-filter>
    </service>

            //采用startService启动服务
            btn_start.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     Intent intent= new Intent(MainActivity.this,MyService.class );
                     startService(intent);
                }
           });

            //销毁服务
            btn_stop.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                      Intent intent=new Intent(MainActivity.this,MyService. class);
                     stopService(intent);
                }
           });

我们发现再次启动时系统并没有重新实例化这个Service，因为系统发现这个服务已经启动了，此时它会直接调用onStartCommand方法，在onStartCommand方法中会调用onStart方法

onStartCommand方法的源码：

     /* @param intent The Intent supplied to {@link android.content.Context#startService},
     * as given.  This may be null if the service is being restarted after
     * its process has gone away, and it had previously returned anything
     * except {@link #START_STICKY_COMPATIBILITY}.
     * @param flags Additional data about this start request.  Currently either
     * 0, {@link #START_FLAG_REDELIVERY}, or {@link #START_FLAG_RETRY}.
     * @param startId A unique integer representing this specific request to
     * start.  Use with {@link #stopSelfResult(int)}.
     *
     * @return The return value indicates what semantics the system should
     * use for the service's current started state.  It may be one of the
     * constants associated with the {@link #START_CONTINUATION_MASK} bits.
     *
     * @see #stopSelfResult(int)
     */
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent , startId);
        return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY;
    }

发现当调用 stopService(intent)这个方法是会调用Service的onDestroy方法从而销毁服务。

2."绑定服务"和"解除绑定"的学习

          //绑定服务
            btn_bind.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     Intent intent = new Intent(MainActivity.this,MyService.class );
                     bindService(intent, conn,Context. BIND_AUTO_CREATE);
                }
           });
            //解除绑定
            btn_unbind.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     unbindService( conn);
                }
           });

  private ServiceConnection conn= new ServiceConnection() {
     /**
     * Called when a connection to the Service has been established, with
     * the {@link android.os.IBinder} of the communication channel to the
     * Service.
     *
     * @param name The concrete component name of the service that has
     * been connected.
     *
     * @param service The IBinder of the Service's communication channel,
     * which you can now make calls on.
     */
       public void onServiceConnected(ComponentName name, IBinder service) {
                 //connected
                Log. i( TAG,"onServiceConnection called." );
           }
     
     /**
     * Called when a connection to the Service has been lost.  This typically
     * happens when the process hosting the service has crashed or been killed.
     * This does <em>not </em> remove the ServiceConnection itself -- this
     * binding to the service will remain active, and you will receive a call
     * to {@link #onServiceConnected} when the Service is next running.
     *
     * @param name The concrete component name of the service whose
     * connection has been lost.
     */
      public void onServiceDisconnected(ComponentName name) {
           
     }
};

     @Override
     public IBinder onBind(Intent intent) {
           Log. i(TAG,"onBind called" );
            return new Binder(){};
     }

上面的代码中返回了一个Binder的实例，而这个Binder恰恰是实现了IBinder接口，所以这样就可以实现绑定服务的操作了

首先我们点击一下”绑定服务“按钮打印日志如下

我们发现onCreate方法、onBind方法和onServiceConnection方法被调用了，此时服务已经进入运行状态，如果此时我们再次点击”绑定服务“按钮,这三个方法都不会被调用然后点击”解除绑定“按钮打印日志如下

可以看到onUnbind方法和onDestroy方法被调用了，此时Service已经被销毁，整个生命周期结束。

由于bindService启动的服务是和应用绑定到一起的所以当MainActivity退出程序时，服务也会随之结束。

下面我们来说一种情况当我们点击"绑定服务"按钮之后我们点击两次“解除绑定”按钮会发现程序崩溃了，日志如下

还有一种情况，当我们点击“绑定服务”按钮后此时服务已经运行了，此时我们直接按“返回”键程序退出了，我们看到日志会报一个错

     //定义一个变量，标识这个服务是否处于绑定状态
     private boolean binded; 
     //定义一个绑定服务的方法
     private void unbindService(){
         if( binded){
                unbindService( conn);
                 binded= false;
           }
      }

      //解除绑定
    btn_unbind.setOnClickListener( new OnClickListener() {
                
     public void onClick(View v) {
         unbindService();
           }
     });
   //在onDestroy方法中调用解除绑定的方法
      protected void onDestroy() {
           unbindService();
     };

3.以上两种启动方法混合使用的学习

在上面我们讨论的都是一对相匹配的启动和销毁方式，可能有的人会问，那我这四个按钮混合着点击会有什么效果呢，接着我们来验证一下

首先我们点击"启动服务"按钮打印日志如下

这个和我们前面讨论的匹配没有问题，接着我们按下绑定服务按钮打印日志如下

调用了onBind方法接着我们点击解除绑定按钮日志如下

此时调用了onUbind方法，值得注意的是此时服务虽然解除了但是没有终止，而是继续运行，这时我们再次点击绑定服务按钮和解除服务按钮发现onbind和onUnbind方法都不会被调用，那么是不是没有绑定成功呢？答案是虽然没有调用onBind方法但是还是绑定成功了，我们可以从如下日志验证

但是我们怎么销毁掉这个服务呢？答案是：如果我们同时使用startService与bindService，Service终止需要unbindService与stopService同时调用，才能终止Service，不管startService与bindServicede的调用顺序，如果先调用unbindService此时服务不会自动终止，再调用stopService之后服务才会停止，如果先调用stopService此时服务也不会终止，而再调用unbindService或者之前调用bindService的context不在了(如Activity被finish的时候)之后服务才会自动停止；