Android四大组件-Service

http://blog.csdn.net/guolin_blog/article/details/11952435

http://www.jianshu.com/p/eeb2bd59853f

• 概述

定义、特点：

Service是可以在后台执行长时间（长生命周期）而又不与用户产生UI交互（没有用户界面）的操作

注意事项：
1、只能在后台运行，即便用户切换了其他应用，启动的Service仍可在后台运行。
2、可以和其他组件进行Service绑定并与之交互，甚至是跨进程通信（IPC）。
3、不能运行在一个独立的进程当中，而是依赖与创建服务时所在的应用组件进程。
4、服务不会自动开启线程，我们需要在服务的内部手动创建子线程，并在这里执行具体的任务。

应用场景举例：
音乐播放：播放多媒体的时候用户启动了其他Activity，此时要在后台继续播放。
记录检测：比如检测SD卡上文件的变化；在后台记录你的地理信息位置的改变等。
其他操作：网络请求、执行文件读写操作或者与 content provider交互。

类型：
本地服务与远程服务

本地服务依附在主进程上，在一定程度上节约了资源。本地服务因为是在同一进程，因此不需要IPC，也不需要AIDL。相应bindService会方便很多。缺点是主进程被kill后，服务变会终止。

远程服务是独立的进程，对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程，因此在Activity所在进程被kill的是偶，该服务依然在运行。缺点是该服务是独立的进程，会占用一定资源，并且使用AIDL进行IPC稍微麻烦一点。本文第六部分将会简单的讲述这一进程间通信方式。

对于startService来说，不管是本地服务还是远程服务，我们需要做的工作都一样简单。

生命周期

• 用法

然后新建一个MyService继承自Service，并重写父类的onCreate()、onStartCommand()和onDestroy()方法，如下所示：

public class MyService extends Service {  

    public static final String TAG = "MyService";  

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate() executed");
    }  

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand() executed");
        return super.onStartCommand(intent, flags, startId);
    }  

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy() executed");
    }  

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }  

}

在Activity里面加入启动Service和停止Service的逻辑

public void onClick(View v) {
        switch (v.getId()) {
        case R.id.start_service:
            Intent startIntent = new Intent(this, MyService.class);
            startService(startIntent);
            break;
        case R.id.stop_service:
            Intent stopIntent = new Intent(this, MyService.class);
            stopService(stopIntent);
            break;
        default:
            break;
        }
    }

另外需要注意，项目中的每一个Service都必须在AndroidManifest.xml中注册才行

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.servicetest"
    android:versionCode="1"
    android:versionName="1.0" >  

    <uses-sdk
        android:minSdkVersion="14"
        android:targetSdkVersion="17" />  

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >  

    ……  

        <service android:name="com.example.servicetest.MyService" >
        </service>
    </application>  

</manifest> 

通过startService方式（继承Service类） 总结
1、启动服务对象多次启动同时只会产生一个，onCreate()方法只会在Service第一次被创建的时候调用，多次点击启动会执行多次onStartCommand()方法，onDestroy()方法只会在Service第一次被停止的时候调用，多次点击停止不会报异常，也不再执行onDestroy()方法。

2、一旦启动，Service将一直运行在后台（run in the background indefinitely）即便启动Service的组件已被destroy。

3、停止一个started服务有两种方法：
（1）在外部使用stopService()手动停止。
（2）在服务内部(onStartCommand方法内部)使用stopSelf()方法，使服务执行完毕后自动停止。比如说，一个start的Service执行在后台下载或上传一个文件的操作，完成之后，Service应自己停止。

4、onStartCommand方法的返回值：
onStartCommand方法执行时，返回的是一个int型。这个整型可以有三个返回值：START_NOT_STICKY、START_STICKY、START_REDELIVER_INTENT
START_NOT_STICKY:“非粘性的”。使用这个返回值时，如果在执行完onStartCommand方法后，服务被异常kill掉，系统不会自动重启该服务。
START_STICKY：如果Service进程被kill掉，保留Service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建Service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到Service，那么参数Intent将为null。
START_REDELIVER_INTENT：重传Intent。使用这个返回值时，系统会自动重启该服务，并将Intent的值传入。

5、默认情况下，一个started的Service与启动他的组件在同一个线程中。上面的实例中，服务就是在主线程中运行的，如果是在服务中完成耗时操作的话，容易造成主线程阻塞。所以我们可以在服务中开启一个子线程来完成耗时操作。

public class MyService extends Service {
    public static final String TAG = "MyService";
   //服务执行的操作
   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
       new Thread(new Runnable() {
           public void run() {
                //在子线程中处理具体的逻辑
                //在这里我们只做打印子线程id的操作
               Log.i("MyService",Thread.currentThread().getId()+"");
               stopSelf();  //服务执行完毕后自动停止
           }
       }).start();
       return super.onStartCommand(intent, flags, startId);
   }

   @Override
   public IBinder onBind(Intent intent) {
       // TODO Auto-generated method stub
       return null;
   }
}

如果我们不手动开启线程，I/MyService: 177将会变成它依赖的主线程1，这就不能做耗时操作了。虽说上面的这种写法并不复杂，但总会有一些程序猿忘记开启线程，或者忘记调用stopSelf()方法。
为了可以简单地创建一个可开启单独线程、会自动停止的服务，Android专门提供了一个IntentService类，这个类就很好的解决了上面所提到的两种尴尬。

IntentService类

IntentService的作用：
当我们需要这样一次性完成的任务时，就可以使用IntentService来完成。

IntentService的用法：

1）新建一个MyIntentService类，继承自IntentService，并重写父类的onHandleIntent()方法，代码如下：

public class MyIntentService extends IntentService{
    public MyIntentService() {
       //第一步：重写父类的onHandleIntent()方法，这里首先要提供一个无参的构造方法，
       //并且必须在其内部调用父类的有参构造方法，这里我们手动给服务起个名字为：MyIntentService
       super("MyIntentService");
   }

     //第二步：重写父类的onHandleIntent()方法，该方法在会在一个单独的线程中执行，
     //来完成工作任务。任务结束后，该Service自动停止
   @Override
   protected void onHandleIntent(Intent intent) {
       for(int i = 0;i<3;i++) {
           //Service要执行的逻辑
           //这里我们只打印当前线程的id
           Log.d("MyIntentService","IntentService线程的id是："+Thread.currentThread().getId());
           try {
               //线程睡眠一秒钟
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

   @Override
   public void onDestroy() {
       super.onDestroy();
       Log.d("MyIntentService","onDestroy");
   }
}

通过startService方式（继承IntentService类） 总结
1、启动一个IntentService和启动一个普通的Service，步骤是相似的。
2、与直接继承Service不同在于：通过继承IntentService运行，自动开启了单独线程，而且完成任务后自动销毁了Service。

【补充】Service和Thread的关系：
不少Android初学者都可能会有这样的疑惑，Service和Thread到底有什么关系呢？什么时候应该用Service，什么时候又应该用Thread？答案可能会有点让你吃惊，因为Service和Thread之间没有任何关系！
之所以有不少人会把它们联系起来，主要就是因为Service的后台概念。Android的后台就是指，它的运行是完全不依赖UI的。即使Activity被销毁，或者程序被关闭，只要进程还在，Service就可以继续运行。Thread我们大家都知道，是用于开启一个子线程，在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候，总会觉得它是用来处理一些后台任务的，一些比较耗时的操作也可以放在这里运行，这就会让人产生混淆了。但是，Service其实是运行在主线程里的，一些比较耗时的操作需要开启单独线程。

通过bindService方式定义一个Service：（使用Bind Service完成Service和Activity之间的通信）：

Bind Service的引入：

有没有什么办法能让Service与组件的关联更多一些呢？比如说在Activity中指挥Service去干什么，Service就去干什么。当然可以，只需要让Activity和Service建立关联就好了。这时我们就可以通过bindService方式定义一个Service。

Bind Service的实现原理：

应用程序组件(客户端）通过调用bindService()方法能够绑定服务，然后Android系统会调用服务的onBind()回调方法，则个方法会返回一个跟服务器端交互的Binder对象。

bindService()方法立即返回，并且不给客户端返回IBinder对象。要接收IBinder对象，客户端必须创建一个ServiceConnection类的实例，并且把这个实例传递给bindService()方法。ServiceConnection对象包含了一个系统调用的传递IBinder对象的回调方法。

Bind Service实现流程：

1）一直有一个onBind()方法我们都没有使用到，这个方法其实就是用于和Activity建立关联的，修改MyService中的代码，如下所示：

public class MyBindService01 extends Service {
  public static final String TAG = "MyBindService01";
  private MyBinder mBinder = new MyBinder();
  @Override
  public void onCreate() {
      super.onCreate();
      Log.d(TAG, "onCreate");
  }

  @Override
  public IBinder onBind(Intent intent) {
      return mBinder;  //在这里返回新建的MyBinder类
  }

  @Override
  public boolean onUnbind(Intent intent) {
      Log.d(TAG, "onUnbind");
      return super.onUnbind(intent);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Log.d(TAG, "onStartCommand");
      return super.onStartCommand(intent, flags, startId);
  }

  @Override
  public void onDestroy() {
      super.onDestroy();
      Log.d(TAG, "onDestroy");
  }

  //MyBinder类，继承Binder：让里面的方法执行下载任务，并获取下载进度
  class MyBinder extends Binder {
      public void startDownload() {
          Log.d("TAG", "startDownload() executed");
          // 执行具体的下载任务
      }
      public int getProgress(){
          Log.d("TAG", "getProgress() executed");
          return 0;
      }
  }
}

• 新建一个MyBinder类，继承Binder：让里面的方法执行下载任务，并获取下载进度。当然，这里只是两个模拟方法，并没有实现真正的功能，我们通过打印日志的形式来体现。
• 接着创建MyBinder的实例，然后在onBind()方法里返回这个实例。返回这个mBinder，是一个IBinder类型，就可以把这个IBinder类型传递到MainActivity中，从而调用Service里面的方法。

2）检查清单文件，是否已经对Service进行注册：
<service android:name=".MyBindService01" ></service>
3）让我们修改MainActivity和MyBindService01之间建立关联

public class MainActivity extends Activity implements OnClickListener {
  private Button button1_bind_service;
  private Button button2_unbind_service;
  private MyBindService01.MyBinder myBinder;

  boolean mBound = false; //一开始，并没有和Service绑定.这个参数是用来显示绑定状态

  //匿名内部类：服务连接对象
  private ServiceConnection connection = new ServiceConnection() {

      //当服务异常终止时会调用。注意，解除绑定服务时不会调用
      @Override
      public void onServiceDisconnected(ComponentName name) {
          mBound = false; //服务异常终止时，状态为未绑定
          //解决了多次执行unbindService()方法引发的异常问题
      }

      //和服务绑定成功后，服务会回调该方法
      @Override
      public void onServiceConnected(ComponentName name, IBinder service) {
          myBinder = (MyBindService01.MyBinder) service;
          //在Activity中调用Service里面的方法
          myBinder.startDownload();
          myBinder.getProgress();
          mBound = true; //true说明是绑定状态
      }
  };
  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
      button1_bind_service = (Button) findViewById(R.id.button1_bind_service);
      button2_unbind_service = (Button) findViewById(R.id.button2_unbind_service);
      button1_bind_service.setOnClickListener(this);
      button2_unbind_service.setOnClickListener(this);
  }
  @Override
  public void onClick(View v) {
      switch (v.getId()) {
      case R.id.button1_bind_service:
          Intent bindIntent = new Intent(this, MyService.class);
          bindService(bindIntent, connection, BIND_AUTO_CREATE);
//这里传入BIND_AUTO_CREATE表示在Activity和Service建立关联后会自动创建Service（即使之前没有创建
//Service也没有关系），这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。
          break;
      case R.id.button2_unbind_service:
          //如果和Service是绑定的状态，就解除绑定。
          if(mBound){
              unbindService(connection);
              mBound=false;
          }
          break;
      default:
          break;
      }
  }
}

说明：这里我们首先创建了一个ServiceConnection的匿名类，在里面重写了onServiceConnected()方法和onServiceDisconnected()方法，如果当前Activity与服务连接成功后，服务会回调onServiceConnected()方法
在onServiceConnected()方法中，我们又通过向下转型得到了MyBinder的实例，有了这个实例，Activity和Service之间的关系就变得非常紧密了。现在我们可以在Activity中根据具体的场景来调用MyBinder中的任何public方法，即实现了Activity指挥Service干什么Service就去干什么的功能。

当然，现在Activity和Service其实还没关联起来了呢，这个功能是在Bind Service按钮的点击事件里完成的。可以看到，这里我们仍然是构建出了一个Intent对象，然后调用bindService()方法将Activity和Service进行绑定。bindService()方法接收三个参数，第一个参数就是刚刚构建出的Intent对象，第二个参数是前面创建出的ServiceConnection的实例，第三个参数是一个标志位，这里传入BIND_AUTO_CREATE表示在Activity和Service建立关联后自动创建Service，这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。

通过bindService方式 总结
1、onCreate()、onBind()方法只会在Service第一次被创建的时候调用，多次点击绑定启动不会执行任何方法，onUnbind()、onDestroy()方法会在调用者执行unbindService()方法时执行或者Activity退出时自动执行。

2、如果我们既通过startService()开启Service，又用通过bindService开启，必要unbindService()和stopService()都执行一次（没有先后顺序），Service才会被销毁。

3、如果多次执行unbinsService()方法，程序会异常退出，我们需要在代码中加一个判断是否绑定的标记mBound来解决此问题，上面代码中有说明。

 case R.id.button4_unbind_service:
          //如果和Service是绑定的状态，就解除绑定。
          if(mBound){
              unbindService(connection);
              mBound=false;
          }
          break;

4、当在旋转手机屏幕的时候，当手机屏幕在“横”“竖”变换时，此时如果你的 Activity 如果会自动旋转的话，旋转其实是 Activity 的重新创建，因此旋转之前的使用 bindService 建立的连接便会断开（Context 不存在了）。

5、只有Activity、Service、Content Provider能够绑定服务；BroadcastReceiver广播接收器不能绑定服务。

、bindService和startService混合使用：

• 如果先startService,再bindService:
  在bind的Activity退出的时候,Service会执行unBind方法而不执行其onDestory方法,因为有startService方法调用过,
  所以Activity与Service解除绑定后会有一个与调用者没有关连的Service存在。

• 如果先bindService,再startService,再调用Context.stopService
  Service的onDestory方法不会立刻执行,因为有一个与Service绑定的Activity,但是在Activity退出的时候,会执行其(Service的)onDestory方法,如果要立刻执行stopService,就得先解除绑定。

• 如果先是bind了，那么start的时候就直接运行Service的onStartCommand()方法，如果先是start，那么bind的时候就直接运行onBind()方法。

• 当一个服务没被onDestory()销毁之前，只有第一个启动它的客户端能调用它的onBind()和onUnbind()。

四、startService、bindService区别大总结

1、生命周期不同。（详见图）
2、多次启动，前者会多次执行onStartCommand()方法，后者什么都不执行。多次停止，前者只会执行一次onDestroy()方法，后者报异常信息。
3、当启动Service的组件已被Destroy的时候，前者不停止，后者会停止。
4、前者停止直接执行onDestroy()方法（Service中的），后者则先解除绑onUnbind()定再执行onDestroy()方法（Service中的）。
5、当手机屏幕在“横”“竖”变换时，前者创建的Service不会停止，后者会随着Activity的重建而停止。
6、后者的onBind回调方法将返回给客户端一个IBinder接口实例，IBinder允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。而这些操作前者启动的Service是没有的。

五、在AndroidManifest.xml里Service元素常见选项

android:name   --　服务类名
android:label  --  服务的名字，如果此项不设置，那么默认显示的服务名则为类名
android:icon　--　服务的图标
android:permission　--　申明此服务的权限，这意味着只有提供了该权限的应用才能控制或连接此服务
android:process　--　表示该服务是否运行在另外一个进程，如果设置了此项，那么将会在包名后面加上这段字符串表示另一进程的名字
android:enabled　--表示是否能被系统实例化，为true表示可以，为false表示不可以，默认为true
android:exported　--　表示该服务是否能够被其他应用程序所控制或连接，不设置默认此项为 false

创建前台Service

 

Service几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。但是Service的系统优先级还是比较低的，当系统出现内存不足情况时，就有可能会回收掉正在后台运行的Service。如果你希望Service可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台Service。前台Service和普通Service最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止Service被回收才使用前台Service，有些项目由于特殊的需求会要求必须使用前台Service，比如说墨迹天气，它的Service在后台更新天气数据的同时，还会在系统状态栏一直显示当前天气的信息，如下图所示：

那么我们就来看一下如何才能创建一个前台Service吧，其实并不复杂，修改MyService中的代码，如下所示：

public class MyService extends Service {  

    public static final String TAG = "MyService";  

    private MyBinder mBinder = new MyBinder();  

    @Override
    public void onCreate() {
        super.onCreate();
        Notification notification = new Notification(R.drawable.ic_launcher,
                "有通知到来", System.currentTimeMillis());
        Intent notificationIntent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
                notificationIntent, 0);
        notification.setLatestEventInfo(this, "这是通知的标题", "这是通知的内容",
                pendingIntent);
        startForeground(1, notification);
        Log.d(TAG, "onCreate() executed");
    }  

    .........  

} 

这里只是修改了MyService中onCreate()方法的代码。可以看到，我们首先创建了一个Notification对象，然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据，并在这里设置了点击通知后就打开MainActivity。然后调用startForeground()方法就可以让MyService变成一个前台Service，并会将通知的图片显示出来。

现在重新运行一下程序，并点击Start Service或Bind Service按钮，MyService就会以前台Service的模式启动了，并且在系统状态栏会弹出一个通栏图标，下拉状态栏后可以看到通知的详细内容