安卓组件service

2022-07-11 22:16:42

【转】http://blog.csdn.net/ithomer/article/details/7364024

一、 Service简介

Service是android 系统中的四大组件之一（Activity、Service、BroadcastReceiver、ContentProvider），它跟Activity的级别差不多，但不能自己运行只能后台运行，并且可以和其他组件进行交互。service可以在很多场合的应用中使用，比如播放多媒体的时候用户启动了其他Activity这个时候程序要在后台继续播放，比如检测SD卡上文件的变化，再或者在后台记录你地理信息位置的改变等等，总之服务总是藏在后台的。

Service的启动有两种方式：context.startService() 和 context.bindService()

 

二、 Service启动流程

context.startService() 启动流程：

context.startService()  -> onCreate()  -> onStart()  -> Service running  -> context.stopService()  -> onDestroy()  -> Service stop

如果Service还没有运行，则android先调用onCreate()，然后调用onStart()；

如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次。

如果stopService的时候会直接onDestroy，如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行，该Service的调用者再启动起来后可以通过stopService关闭Service。

所以调用startService的生命周期为：onCreate --> onStart (可多次调用) --> onDestroy

context.bindService()启动流程：

context.bindService()  -> onCreate()  -> onBind()  -> Service running  -> onUnbind()  -> onDestroy()  -> Service stop

onBind()将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service的实例、运行状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind->onDestroy相应退出。

所以调用bindService的生命周期为：onCreate --> onBind(只一次，不可多次绑定) --> onUnbind --> onDestory。

在Service每一次的开启关闭过程中，只有onStart可被多次调用(通过多次startService调用)，其他onCreate，onBind，onUnbind，onDestory在一个生命周期中只能被调用一次。

安卓组件service

三、 Service生命周期 

Service的生命周期并不像Activity那么复杂，它只继承了onCreate()、onStart()、onDestroy()三个方法

当我们第一次启动Service时，先后调用了onCreate()、onStart()这两个方法；当停止Service时，则执行onDestroy()方法。

这里需要注意的是，如果Service已经启动了，当我们再次启动Service时，不会在执行onCreate()方法，而是直接执行onStart()方法。

它可以通过Service.stopSelf()方法或者Service.stopSelfResult()方法来停止自己，只要调用一次stopService()方法便可以停止服务，无论调用了多少次的启动服务方法。

四、 Service示例（startservice）

下面我做了一个简单的音乐播放的应用，分别使用startService和bindService来启动本地的服务。

Activity

  1. public class PlayMusicService extends Activity implements OnClickListener {
  2. private Button playBtn;
  3. private Button stopBtn;
  4. private Button pauseBtn;
  5. private Button exitBtn;
  6. private Button closeBtn;
  7. private Intent intent;
  8. @Override
  9. public void onCreate(Bundle savedInstanceState) {
  10. super.onCreate(savedInstanceState);
  11. setContentView(R.layout.music_service);
  12. playBtn = (Button) findViewById(R.id.play);
  13. stopBtn = (Button) findViewById(R.id.stop);
  14. pauseBtn = (Button) findViewById(R.id.pause);
  15. exitBtn = (Button) findViewById(R.id.exit);
  16. closeBtn = (Button) findViewById(R.id.close);
  17. playBtn.setOnClickListener(this);
  18. stopBtn.setOnClickListener(this);
  19. pauseBtn.setOnClickListener(this);
  20. exitBtn.setOnClickListener(this);
  21. closeBtn.setOnClickListener(this);
  22. }
  23. @Override
  24. public void onClick(View v) {
  25. int op = -1;
  26. intent = new Intent("com.homer.service.musicService");
  27. switch (v.getId()) {
  28. case R.id.play:                             // play music
  29. op = 1;
  30. break;
  31. case R.id.stop:                             // stop music
  32. op = 2;
  33. break;
  34. case R.id.pause:                            // pause music
  35. op = 3;
  36. break;
  37. case R.id.close:                            // close activity
  38. this.finish();
  39. break;
  40. case R.id.exit:                             // stopService
  41. op = 4;
  42. stopService(intent);
  43. this.finish();
  44. break;
  45. }
  46.  Bundle bundle = new Bundle();  
  47.         bundle.putInt("op", op);  
  48.         intent.putExtras(bundle);
  49. startService(intent);                           // startService
  50. }
  51. @Override
  52. public void onDestroy(){
  53. super.onDestroy();
  54. if(intent != null){
  55. stopService(intent);
  56. }
  57. }
  58. }

Service

  1. public class MusicService extends Service {
  2. private static final String TAG = "MyService";
  3. private MediaPlayer mediaPlayer;
  4. @Override
  5. public IBinder onBind(Intent arg0) {
  6. return null;
  7. }
  8. @Override
  9. public void onCreate() {
  10. Log.v(TAG, "onCreate");
  11. Toast.makeText(this, "show media player", Toast.LENGTH_SHORT).show();
  12. if (mediaPlayer == null) {
  13. mediaPlayer = MediaPlayer.create(this, R.raw.tmp);
  14. mediaPlayer.setLooping(false);
  15. }
  16. }
  17. @Override
  18. public void onDestroy() {
  19. Log.v(TAG, "onDestroy");
  20. Toast.makeText(this, "stop media player", Toast.LENGTH_SHORT);
  21. if (mediaPlayer != null) {
  22. mediaPlayer.stop();
  23. mediaPlayer.release();
  24. }
  25. }
  26. @Override
  27. public void onStart(Intent intent, int startId) {
  28. Log.v(TAG, "onStart");
  29. if (intent != null) {
  30.   Bundle bundle = intent.getExtras();  //通过intent传递的参数和调用者进行通信
  31. if (bundle != null) {
  32. int op = bundle.getInt("op");
  33. switch (op) {
  34. case 1:
  35. play();
  36. break;
  37. case 2:
  38. stop();
  39. break;
  40. case 3:
  41. pause();
  42. break;
  43. }
  44. }
  45. }
  46. }
  47. public void play() {
  48. if (!mediaPlayer.isPlaying()) {
  49. mediaPlayer.start();
  50. }
  51. }
  52. public void pause() {
  53. if (mediaPlayer != null && mediaPlayer.isPlaying()) {
  54. mediaPlayer.pause();
  55. }
  56. }
  57. public void stop() {
  58. if (mediaPlayer != null) {
  59. mediaPlayer.stop();
  60. try {
  61. mediaPlayer.prepare();  // 在调用stop后如果需要再次通过start进行播放,需要之前调用prepare函数
  62. } catch (IOException ex) {
  63. ex.printStackTrace();
  64. }
  65. }
  66. }
  67. }

AndroidManifest.xml

注册activity

  1. <activity
  2. android:name=".service.PlayMusicService"
  3. android:label="@string/app_name" />

注册service

  1. <service
  2. android:name=".service.MusicService"
  3. android:enabled="true" >
  4. <intent-filter>
  5. <action android:name="com.homer.service.musicService" />
  6. </intent-filter>
  7. </service>

五、 代码解析

1、Activity中，PlayMusicService中通过重写OnClickListener 接口onClick()方法实现对播放音乐的控制，把音乐各种操作用数字通过Intent传递给service

然后通过构造一个Intent ， intent = new Intent("com.homer.service.musicService");

其中，com.homer.service.musicService是 AndroidManifest.xml 对service的定义，即上面“注册service”

2、Activity中，音乐播放的控制，利用Bundle绑定数字op后，通过 startService(intent); 服务后发送出去
Bundle bundle = new Bundle();
bundle.putInt("op", op);
intent.putExtras(bundle);

startService(intent);

3、 Service中，会处理Activity启动的 startService(intent);服务，依次调用service的启动过程：onCreate --> onStart(可多次调用) --> onDestroy

onCreate()，  创建mediaPlayer

onStart()，      通过获取Bundle bundle = intent.getExtras();，提取int op = bundle.getInt("op");，然后执行响应的音乐播放操作

onDestroy()，停止并释放mediaPlayer音乐资源，如果当执行context.stopService()时调用此方法

4、Activity中，onClick()函数中close与exit是执行含义是不同的：

close ： 只是执行了this.finish(); 关闭了本Activity窗体，service并没有被关掉，音乐依然会继续在后台播放

exit  ： 先调用了stopService(intent); 关闭了service服务，在Service中会调用3中的onDestroy()停止并释放音乐资源，后才执行this.finish(); 关闭了本Activity窗体

参考推荐：

android service 学习

Android Service生命周期及用法

Android生命周期之service/Broadcast

Android BroadcastReceiver 学习

Android之BroadcastReceiver的使用

Android BroadcastReceiver启动Service

Service (android developer)

源码下载

 六、Service示例(bindservice）【转】http://blog.csdn.net/ithomer/article/details/7366396

一、bindService简介

bindService是绑定Service服务，执行service服务中的逻辑流程。

service通过Context.startService()方法开始，通过Context.stopService()方法停止；也可以通过Service.stopSelf()方法或者Service.stopSelfResult()方法来停止自己。只要调用一次stopService()方法便可以停止服务，无论之前它被调用了多少次的启动服务方法。

客户端建立一个与Service的连接，并使用此连接与Service进行通话，通过Context.bindService()方法来绑定服务，Context.unbindService()方法来关闭服务。多个客户端可以绑定同一个服务，如果Service还未被启动，bindService()方法可以启动服务。

上面startService()和bindService()两种模式是完全独立的。你可以绑定一个已经通过startService()方法启动的服务。例如：一个后台播放音乐服务可以通过startService(intend)对象来播放音乐。可能用户在播放过程中要执行一些操作比如获取歌曲的一些信息，此时activity可以通过调用bindServices()方法与Service建立连接。这种情况下，stopServices()方法实际上不会停止服务，直到最后一次绑定关闭。

二、bindService启动流程

context.bindService()  ——> onCreate()  ——> onBind()  ——> Service running  ——> onUnbind()  ——> onDestroy()  ——> Service stop

onBind()将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service的实例、运行状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind->onDestroy相应退出。

所以调用bindService的生命周期为：onCreate --> onBind(只一次，不可多次绑定) --> onUnbind --> onDestory。

在Service每一次的开启关闭过程中，只有onStart可被多次调用(通过多次startService调用)，其他onCreate，onBind，onUnbind，onDestory在一个生命周期中只能被调用一次。详见：Android Service 服务（一）—— Service

三、bindService生命周期

像一个activity那样，一个service有些可以用来改变状态的生命周期方法，但是比activity的方法少，service生命周期方法只有三个public

void onCreate()

void onStart(Intent intent)

void onDestroy()

通过实现这三个生命周期方法，你可以监听service的两个嵌套循环的生命周期：

1、整个生命周期

service的整个生命周期是在onCreate()和onDestroy()方法之间。和activity一样，在onCreate()方法里初始化，在onDestroy()方法里释放资源。例如，一个背景音乐播放服务可以在onCreate()方法里播放，在onDestroy()方法里停止。

2、活动的生命周期

service的活动生命周期是在onStart()之后，这个方法会处理通过startServices()方法传递来的Intent对象。音乐service可以通过开打intent对象来找到要播放的音乐，然后开始后台播放。注： service停止时没有相应的回调方法，即没有onStop()方法，只有onDestroy()销毁方法。

onCreate()方法和onDestroy()方法是针对所有的services，无论它们是否启动，通过Context.startService()和Context.bindService()方法都可以访问执行。然而，只有通过startService()方法启动service服务时才会调用onStart()方法。

安卓组件service

如果一个service允许别人绑定，那么需要实现以下额外的方法：

IBinder onBind(Intent intent)

boolean onUnbind(Intent intent)

void onRebind(Intent intent)

onBind()回调方法会继续传递通过bindService()传递来的intent对象

onUnbind()会处理传递给unbindService()的intent对象。如果service允许绑定，onBind()会返回客户端与服务互相联系的通信句柄（实例）。

如果建立了一个新的客户端与服务的连接，onUnbind()方法可以请求调用onRebind()方法。

记住： 任何服务无论它怎样建立，默认客户端都可以连接，所以任何service都能够接收onBind()和onUnbind()方法

四、bindService示例

Activity

  1. public class PlayBindMusic extends Activity implements OnClickListener {
  2. private Button playBtn;
  3. private Button stopBtn;
  4. private Button pauseBtn;
  5. private Button exitBtn;
  6. private BindMusicService musicService;
  7. @Override
  8. public void onCreate(Bundle savedInstanceState) {
  9. super.onCreate(savedInstanceState);
  10. setContentView(R.layout.bind_music_service);
  11. playBtn = (Button) findViewById(R.id.play);
  12. stopBtn = (Button) findViewById(R.id.stop);
  13. pauseBtn = (Button) findViewById(R.id.pause);
  14. exitBtn = (Button) findViewById(R.id.exit);
  15. playBtn.setOnClickListener(this);
  16. stopBtn.setOnClickListener(this);
  17. pauseBtn.setOnClickListener(this);
  18. exitBtn.setOnClickListener(this);
  19. connection();
  20. }
  21. private void connection() {
  22. Intent intent = new Intent("com.homer.bind.bindService");
  23. bindService(intent, sc, Context.BIND_AUTO_CREATE);          // bindService
  24. }
  25. @Override
  26. public void onClick(View v) {
  27. switch (v.getId()) {
  28. case R.id.play:
  29. musicService.play();
  30. break;
  31. case R.id.stop:
  32. if (musicService != null) {
  33. musicService.stop();
  34. }
  35. break;
  36. case R.id.pause:
  37. if (musicService != null) {
  38. musicService.pause();
  39. }
  40. break;
  41. case R.id.exit:
  42. this.finish();
  43. break;
  44. }
  45. }
  46. private ServiceConnection sc = new ServiceConnection() {
  47. @Override
  48. public void onServiceConnected(ComponentName name, IBinder service) {       //connect Service
  49. musicService = ((BindMusicService.MyBinder) (service)).getService();  
  50.             if (musicService != null) {  
  51.                 musicService.play();        // play music  ，通过MyBinder获取到service实例，调用service中定义的方法
  52.             }  
  53. }
  54. @Override
  55. public void onServiceDisconnected(ComponentName name) {                 //disconnect Service
  56. musicService = null;
  57. }
  58. };
  59. @Override
  60. public void onDestroy(){
  61. super.onDestroy();
  62. if(sc != null){
  63. unbindService(sc);
  64. }
  65. }
  66. }

Service

  1. public class BindMusicService extends Service {
  2. private MediaPlayer mediaPlayer;
  3. private final IBinder binder = new MyBinder();
  4. public class MyBinder extends Binder {
  5. BindMusicService getService() {
  6. return BindMusicService.this;
  7. }
  8. }
  9. @Override
  10. public IBinder onBind(Intent intent) {
  11. return binder;
  12. }
  13. @Override
  14. public void onCreate() {
  15. super.onCreate();
  16. Toast.makeText(this, "show media player", Toast.LENGTH_SHORT).show();
  17. }
  18. @Override
  19. public void onDestroy() {
  20. super.onDestroy();
  21. Toast.makeText(this, "stop media player", Toast.LENGTH_SHORT);
  22. if(mediaPlayer != null){
  23. mediaPlayer.stop();
  24. mediaPlayer.release();
  25. }
  26. }
  27. public void play() {
  28. if (mediaPlayer == null) {
  29. mediaPlayer = MediaPlayer.create(this, R.raw.tmp);
  30. mediaPlayer.setLooping(false);
  31. }
  32. if (!mediaPlayer.isPlaying()) {
  33. mediaPlayer.start();
  34. }
  35. }
  36. public void pause() {
  37. if (mediaPlayer != null && mediaPlayer.isPlaying()) {
  38. mediaPlayer.pause();
  39. }
  40. }
  41. public void stop() {
  42. if (mediaPlayer != null) {
  43. mediaPlayer.stop();
  44. try {
  45. mediaPlayer.prepare();      // 在调用stop后如果需要再次通过start进行播放,需要之前调用prepare函数
  46. } catch (IOException ex) {
  47. ex.printStackTrace();
  48. }
  49. }
  50. }
  51. }

AndroidManifest.xml

  1. <service
  2. android:name=".bind.BindMusicService"
  3. android:enabled="true" >
  4. <intent-filter>
  5. <action android:name="com.homer.bind.bindService" />
  6. </intent-filter>
  7. </service>

五、代码解析

1、 Activity中，Intent intent = new Intent("com.homer.bind.bindService"); 构建一个service的action，然后bindService(intent, sc, Context.BIND_AUTO_CREATE); 绑定服务

2、 Activity中，通过private ServiceConnection sc = new ServiceConnection() 建立一个Service连接，onServiceConnected()获取Service实例，onServiceDisconnected()释放连接

3、 Service中，重载onBind(Intent intent)方法，返回Service实例（即BindMusicService）给Activity，然后执行onCreate()函数（注：bindService不执行onStart()函数）

4、 Activity中，通过返回的Service实例musicService，执行音乐播放的操作（play、pause、stop等）

六、Remote Service拓展

通常每个应用程序都在它自己的进程内运行，但有时需要在进程之间传递对象（IPC通信），你可以通过应用程序UI的方式写个运行在一个不同的进程中的service。在android平台中，一个进程通常不能访问其它进程中的内存区域。所以，他们需要把对象拆分成操作系统能理解的简单形式，以便伪装成对象跨越边界访问。编写这种伪装代码相当的枯燥乏味，好在android为我们提供了AIDL工具可以来做这件事。
 
AIDL(android接口描述语言)是一个IDL语言，它可以生成一段代码，可以使在一个android设备上运行的两个进程使用内部通信进程进行交互。如果你需要在一个进程中(例如在一个Activity中)访问另一个进程中(例如一个Service)某个对象的方法，你就可以使用AIDL来生成这样的代码来伪装传递各种参数。
 
要使用AIDL，Service需要以aidl文件的方式提供服务接口，AIDL工具将生成一个相应的java接口，并且在生成的服务接口中包含一个功能调用的stub服务桩类。Service的实现类需要去继承这个stub服务桩类。Service的onBind方法会返回实现类的对象，之后你就可以使用它了，参见下例：

IMusicControlService.aidl

  1. package com.homer.remote;
  2. interface IMusicControlService{
  3. void play();
  4. void stop();
  5. void pause();
  6. }
 
使用eclipse的Android插件，会根据这个aidl文件生成一个Java接口类，生成的接口类中会有一个内部类Stub类，Service来继承该Stub类：
Service
  1. public class RemoteMusicService extends Service {
  2. private MediaPlayer mediaPlayer;
  3. @Override
  4. public IBinder onBind(Intent intent) {
  5. return binder;
  6. }
  7. private final IMusicControlService.Stub binder = new IMusicControlService.Stub() {
  8. @Override
  9. public void play() throws RemoteException {
  10. if (mediaPlayer == null) {
  11. mediaPlayer = MediaPlayer.create(RemoteMusicService.this, R.raw.tmp);
  12. mediaPlayer.setLooping(false);
  13. }
  14. if (!mediaPlayer.isPlaying()) {
  15. mediaPlayer.start();
  16. }
  17. }
  18. @Override
  19. public void pause() throws RemoteException {
  20. if (mediaPlayer != null && mediaPlayer.isPlaying()) {
  21. mediaPlayer.pause();
  22. }
  23. }
  24. @Override
  25. public void stop() throws RemoteException {
  26. if (mediaPlayer != null) {
  27. mediaPlayer.stop();
  28. try {
  29. mediaPlayer.prepare();      // 在调用stop后如果需要再次通过start进行播放,需要之前调用prepare函数
  30. } catch (IOException ex) {
  31. ex.printStackTrace();
  32. }
  33. }
  34. }
  35. };
  36. @Override
  37. public void onDestroy() {
  38. super.onDestroy();
  39. if(mediaPlayer != null){
  40. mediaPlayer.stop();
  41. mediaPlayer.release();
  42. }
  43. }
  44. }

客户端（Activity）应用连接到这个Service时，onServiceConnected方法将被调用，客户端就可以获得IBinder对象。参看下面的客户端onServiceConnected方法：

Activity

  1. public class PlayRemoteMusic extends Activity implements OnClickListener {
  2. private Button playBtn;
  3. private Button stopBtn;
  4. private Button pauseBtn;
  5. private Button exitBtn;
  6. private IMusicControlService musicService;
  7. @Override
  8. public void onCreate(Bundle savedInstanceState) {
  9. super.onCreate(savedInstanceState);
  10. setContentView(R.layout.remote_music_service);
  11. playBtn = (Button) findViewById(R.id.play);
  12. stopBtn = (Button) findViewById(R.id.stop);
  13. pauseBtn = (Button) findViewById(R.id.pause);
  14. exitBtn = (Button) findViewById(R.id.exit);
  15. playBtn.setOnClickListener(this);
  16. stopBtn.setOnClickListener(this);
  17. pauseBtn.setOnClickListener(this);
  18. exitBtn.setOnClickListener(this);
  19. connection();
  20. }
  21. private void connection() {
  22. Intent intent = new Intent("com.homer.remote.remoteMusicReceiver");
  23. bindService(intent, sc, Context.BIND_AUTO_CREATE);              // bindService
  24. }
  25. @Override
  26. public void onClick(View v) {
  27. try {
  28. switch (v.getId()) {
  29. case R.id.play:
  30. musicService.play();
  31. break;
  32. case R.id.stop:
  33. if (musicService != null) {
  34. musicService.stop();
  35. }
  36. break;
  37. case R.id.pause:
  38. if (musicService != null) {
  39. musicService.pause();
  40. }
  41. break;
  42. case R.id.exit:
  43. this.finish();
  44. break;
  45. }
  46. } catch (RemoteException e) {
  47. e.printStackTrace();
  48. }
  49. }
  50. private ServiceConnection sc = new ServiceConnection() {
  51. @Override
  52. public void onServiceConnected(ComponentName name, IBinder service) {       //connect Service
  53. musicService = IMusicControlService.Stub.asInterface(service);
  54. }
  55. @Override
  56. public void onServiceDisconnected(ComponentName name) {                 //disconnect Service
  57. musicService = null;
  58. }
  59. };
  60. @Override
  61. public void onDestroy(){
  62. super.onDestroy();
  63. if(sc != null){
  64. unbindService(sc);              // unBindService
  65. }
  66. }
  67. }

Remote Service流程总结：

1、 Activity（客户端）中，Intent intent = new Intent("com.homer.remote.remoteMusicReceiver");构建intent，然后bindService(intent, sc, Context.BIND_AUTO_CREATE);绑定服务

2、 Activity（客户端）中，通过ServiceConnection()重载onServiceConnected()建立连接，获取Service.Stub实例；onServiceDisconnected()释放连接（与bindService类似）

3、 Service中，通过重载onBind(Intent intent) 返回Service.Stub实例，但Service.Stub类是由aidl文件生成的接口类中的一个内部类Stub类，Service来继承该Stub类

4、 Activity中，通过操作Service实例（musicService），执行音乐播放操作（play、pause、stop等）

源码下载

参考推荐：

Service (android developer)

Android Service 服务（一）—— Service

Android Service 服务（二）—— BroadcastReceiver

android中service和aidl详细整理

Android Service AIDL

android笔记--Service与AIDL

七、 组件的通信（remoteservice详细）

1. 以startService(Intent intent)的方式启动. 此时启动的Service与调用者之间没有关联, 即使调用者已经退出, Service仍然可以继续运行, 而且调用者和Service之间无法进行数据交换和通信. 如果需要停止Service的运行, 只能调用Context类的stopService(intent)方法, 或者由Service本身调用其stopSelf()等方法.（第一个startservice的例子实际上是通过intent携带的参数来进行通信的）

2. 以bindService(Intent service, ServiceConnection conn, int flags)的方式启动.

此时调用者与Service绑定在一起, 如果调用者退出, 则Service也随之退出, 而且调用者和Service之间可以进行数据交换或通信.

根据调用者和Service是否在一个应用程序内, 可以将调用者和Service之间的通信分为进程内通信和进程间通信.

a. 进程内通信. bindService(Intent service, ServiceConnection conn, int flags)方法的第二个参数为ServiceConnection对象, 最后一个参数通常可以是Service.BIND_AUTO_CREATE. ServiceConnection是一个接口, 该接口包含2个方法:

|-- onServiceConnected(ComponentName name, IBinder service): 该方法在调用者和Service成功绑定之后由系统回调.

方法中的第一个参数ComponentName是所绑定的Service的组件名称, 而IBinder对象就是Service中onBinder()方法的返回值. 要实现调用者和Service之间的通信, 只需要调用IBinder对象中定义的方法即可.

b.进程间通信. 调用者和Service如果不在一个进程内, 就需要使用android中的远程Service调用机制.（在一个进程定义了一个AIDL接口包，这个包里提供了一个静态的binder类，然后在另一个进程中引入这个包，通过得到这个binder来实现接口中定义的方法）

android使用AIDL定义进程间的通信接口. AIDL的语法与java接口类似, 需要注意以下几点:

1. AIDL文件必须以.aidl作为后缀名.

2. AIDL接口中用到的数据类型, 除了基本类型, String, List, Map, CharSequence之外, 其他类型都需要导包, 即使两种在同一个包内. List和Map中的元素类型必须是AIDL支持的类型.

3. 接口名需要和文件名相同.

4. 方法的参数或返回值是自定义类型时, 该自定义的类型必须实现了Parcelable接口.

5. 所有非java基本类型参数都需要加上in, out, inout标记, 以表明参数是输入参数, 输出参数, 还是输入输出参数.

6. 接口和方法前不能使用访问修饰符和static, final等修饰.

 示例参考：【转】http://coolxing.iteye.com/blog/1222602

Service是android中的服务组件, 经常用来执行一些运行在后台的耗时操作. 使用一个Service需要继承Service类, 并根据需要重写生命周期方法. Service的生命周期如下:

安卓组件service

|-- public abstract IBinder onBind (Intent intent): 该方法是一个抽象方法, 因此Service子类必须实现这个方法. 它返回一个IBinder对象, 应用程序可以通过这个对象与Service组件通信(关于这一点, 其后会有详细的讲解), 以bindService()方式启动Service时回调该方法.

|-- public void onCreate (): 当Service第一次被创建后回调的方法.

|-- public void onDestroy (): Service关闭之前回调的方法.

|-- public int onStartCommand (Intent intent, int flags, int startId): 以startService(Intent intent)的方式启动Service时, 系统都会回调该方法.

|-- public boolean onUnbind (Intent intent): 当所有绑定该Service的组件都断开连接时回调该方法.

从图中可以看出, Service可以有两种启动方式:

1. 以startService(Intent intent)的方式启动. 此时启动的Service与调用者之间没有关联, 即使调用者已经退出, Service仍然可以继续运行, 而且调用者和Service之间无法进行数据交换和通信. 如果需要停止Service的运行, 只能调用Context类的stopService(intent)方法, 或者由Service本身调用其stopSelf()等方法.

2. 以bindService(Intent service, ServiceConnection conn, int flags)的方式启动.

此时调用者与Service绑定在一起, 如果调用者退出, 则Service也随之退出, 而且调用者和Service之间可以进行数据交换或通信.

根据调用者和Service是否在一个应用程序内, 可以将调用者和Service之间的通信分为进程内通信和进程间通信.

a. 进程内通信. bindService(Intent service, ServiceConnection conn, int flags)方法的第二个参数为ServiceConnection对象, 最后一个参数通常可以是Service.BIND_AUTO_CREATE. ServiceConnection是一个接口, 该接口包含2个方法:

|-- onServiceConnected(ComponentName name, IBinder service): 该方法在调用者和Service成功绑定之后由系统回调.

方法中的第一个参数ComponentName是所绑定的Service的组件名称, 而IBinder对象就是Service中onBinder()方法的返回值. 要实现调用者和Service之间的通信, 只需要调用IBinder对象中定义的方法即可.

|-- onServiceDisconnected(ComponentName name): 该方法在调用者解除和Service的绑定之后由系统回调.

以下是利用Service实现进程内通信的一个例子.

首先自定义Service类:

  1. public class MyService extends Service {
  2. public class MyBinder extends Binder {
  3. /**
  4. * 获取Service的运行时间
  5. * @return
  6. */
  7. public long getServiceRunTime() {
  8. return System.currentTimeMillis() - startTime;
  9. }
  10. }
  11. private long startTime;
  12. /**
  13. * MyBinder是Binder的子类, 而Binder实现了IBinder接口.
  14. */
  15. @Override
  16. public IBinder onBind(Intent intent) {
  17. return new MyBinder();
  18. }
  19. @Override
  20. public void onCreate() {
  21. super.onCreate();
  22. startTime = System.currentTimeMillis();
  23. }
  24. }

然后在activity中绑定上述的Service:

  1. public class MainActivity extends Activity {
  2. private MyBinder binder = null;
  3. /** Called when the activity is first created. */
  4. @Override
  5. public void onCreate(Bundle savedInstanceState) {
  6. super.onCreate(savedInstanceState);
  7. setContentView(R.layout.main);
  8. // 创建一个指向MyService的intent
  9. Intent intent = new Intent("cn.xing.action.my_service");
  10. this.bindService(intent, new MyServiceConnection(),
  11. Service.BIND_AUTO_CREATE);
  12. Button button = (Button) this.findViewById(R.id.button);
  13. button.setOnClickListener(new View.OnClickListener() {
  14. @Override
  15. public void onClick(View v) {
  16. if (binder != null) {
  17. Toast.makeText(getApplicationContext(), "MyService已经运行了" + binder.getServiceRunTime()
  18. + "毫秒", Toast.LENGTH_LONG).show();
  19. }
  20. }
  21. });
  22. }
  23. /**
  24. * 实现ServiceConnection接口
  25. *
  26. * @author xing
  27. *
  28. */
  29. private final class MyServiceConnection implements ServiceConnection {
  30. /**
  31. * 和MyService绑定时系统回调这个方法
  32. */
  33. @Override
  34. public void onServiceConnected(ComponentName name, IBinder service) {
  35. // MyService中的onBinder()方法的返回值实际上是一个MyBinder对象, 因此可以使用强制转换.
  36. binder = (MyBinder) service;
  37. }
  38. /**
  39. * 解除和MyService的绑定时系统回调这个方法
  40. */
  41. @Override
  42. public void onServiceDisconnected(ComponentName name) {
  43. // 解除和MyService的绑定后, 将binder设置为null.
  44. binder = null;
  45. }
  46. }
  47. }

b.进程间通信. 调用者和Service如果不在一个进程内, 就需要使用android中的远程Service调用机制.

android使用AIDL定义进程间的通信接口. AIDL的语法与java接口类似, 需要注意以下几点:

1. AIDL文件必须以.aidl作为后缀名.

2. AIDL接口中用到的数据类型, 除了基本类型, String, List, Map, CharSequence之外, 其他类型都需要导包, 即使两种在同一个包内. List和Map中的元素类型必须是AIDL支持的类型.

3. 接口名需要和文件名相同.

4. 方法的参数或返回值是自定义类型时, 该自定义的类型必须实现了Parcelable接口.

5. 所有非java基本类型参数都需要加上in, out, inout标记, 以表明参数是输入参数, 输出参数, 还是输入输出参数.

6. 接口和方法前不能使用访问修饰符和static, final等修饰.

下面通过一个例子来演示android远程Service调用机制的各个步骤:

1. 创建remoteService项目.

2. 在cn.xing.remoteservice包下定义aidl文件--IRemoteService.aidl:

  1. package cn.xing.remoteservice;
  2. interface IRemoteService{
  3. int getServiceRunTime();
  4. }

Eclipse的ADT插件会在gen目录的cn.xing.remoteservice包下自动根据aidl文件生成IRemoteService接口.

接口中有一个static的抽象内部类Stub, Stub类继承了Binder类并实现了IRemoteService接口. Stub类有如下的静态方法:

public static cn.xing.remoteservice.IRemoteService asInterface(android.os.IBinder obj)

该方法接受一个IBinder对象, 返回值是IRemoteService的instance, 通过这个instance我们就可以调用IRemoteService中定义的方法了.

3. 在remoteService项目的cn.xing.remoteservice包下创建远程服务类RemoteService:

  1. public class RemoteService extends Service {
  2. private long startTime;
  3. /**
  4. * IRemoteService.Stub类实现了IBinder和IRemoteService接口
  5. * 因此Stub的子类对象可以作为onBinder()方法的返回值.
  6. * @author xing
  7. *
  8. */
  9. public class MyBinder extends IRemoteService.Stub {
  10. @Override
  11. public long getServiceRunTime() throws RemoteException {
  12. return System.currentTimeMillis() - startTime;
  13. }
  14. };
  15. @Override
  16. public IBinder onBind(Intent intent) {
  17. return new MyBinder();
  18. }
  19. @Override
  20. public void onCreate() {
  21. super.onCreate();
  22. startTime = System.currentTimeMillis();
  23. }
  24. }

4. 创建一个新的android项目invokeRemoteService, 并复制remoteService项目中的aidl文件(连同包结构一起复制)到invokeRemoteService项目中.

5. 在invokeRemoteService项目中绑定远程服务, 并调用远程方法.

  1. public class MainActivity extends Activity {
  2. private IRemoteService iRemoteService = null;
  3. /** Called when the activity is first created. */
  4. @Override
  5. public void onCreate(Bundle savedInstanceState) {
  6. super.onCreate(savedInstanceState);
  7. setContentView(R.layout.main);
  8. // 创建一个指向RemoteService的intent
  9. Intent intent = new Intent("cn.xing.action.remote_service");
  10. this.bindService(intent, new MyServiceConnection(),
  11. Service.BIND_AUTO_CREATE);
  12. Button button = (Button) this.findViewById(R.id.button);
  13. button.setOnClickListener(new View.OnClickListener() {
  14. @Override
  15. public void onClick(View v) {
  16. if (iRemoteService != null) {
  17. try {
  18. Toast.makeText(getApplicationContext(), "MyService已经运行了" + iRemoteService.getServiceRunTime()
  19. + "毫秒", Toast.LENGTH_LONG).show();
  20. } catch (RemoteException e) {
  21. e.printStackTrace();
  22. }
  23. }
  24. }
  25. });
  26. }
  27. /**
  28. * 实现ServiceConnection接口
  29. *
  30. * @author xing
  31. *
  32. */
  33. private final class MyServiceConnection implements ServiceConnection {
  34. /**
  35. * 和RemoteService绑定时系统回调这个方法
  36. */
  37. @Override
  38. public void onServiceConnected(ComponentName name, IBinder service) {
  39. // 此处不能使用强制转换, 应该调用Stub类的静态方法获得IRemoteService接口的实例对象
  40. iRemoteService = IRemoteService.Stub.asInterface(service);
  41. }
  42. /**
  43. * 解除和RemoteService的绑定时系统回调这个方法
  44. */
  45. @Override
  46. public void onServiceDisconnected(ComponentName name) {
  47. // 解除和RemoteService的绑定后, 将iRemoteService设置为null.
  48. iRemoteService = null;
  49. }
  50. }
  51. }

附件中包含进程内通信和进程间通信例子的源码, 需要的朋友可自行下载查看.

 

八、 拓展知识（进程和声明周期）

Android操作系统尝试尽可能长时间的保持应用的进程，但当可用内存很低时最终要移走一部分进程。怎样确定那些程序可以运行，那些要被销毁，Android让每一个进程在一个重要级的基础上运行，重要级低的进程最有可能被淘汰，一共有5级，下面这个列表就是按照重要性排列的：

1 一个前台进程显示的是用户此时需要处理和显示的。下列的条件有任何一个成立，这个进程都被认为是在前台运行的。
        a 与用户正发生交互的。
        b 它控制一个与用户交互的必须的基本的服务。
        c 有一个正在调用生命周期的回调函数的service（如onCreate()、onStar()、onDestroy()）
        d 它有一个正在运行onReceive()方法的广播接收对象。
只有少数的前台进程可以在任何给定的时间内运行，销毁他们是系统万不得已的、最后的选择——当内存不够系统继续运行下去时。通常，在这一点上，设备已经达到了内存分页状态，所以杀掉一些前台进程来保证能够响应用户的需求。

2 一个可用进程没有任何前台组件，但它仍然可以影响到用户的界面。下面两种情况发生时，可以称该进程为可用进程。
        它是一个非前台的activity，但对用户仍然可用（onPause()方法已经被调用）这是可能发生的，例如：前台的activity是一个允许上一个activity可见的对话框，即当前activity半透明，能看到前一个activity的界面，它是一个服务于可用activity的服务。

3 一个服务进程是一个通过调用startService()方法启动的服务，并且不属于前两种情况。尽管服务进程没有直接被用户看到，但他们确实是用户所关心的，比如后台播放音乐或网络下载数据。所以系统保证他们的运行，直到不能保证所有的前台可见程序都正常运行时才会终止他们。

4 一个后台进程就是一个非当前正在运行的activity（activity的onStop()方法已经被调用），他们不会对用户体验造成直接的影响，当没有足够内存来运行前台可见程序时，他们将会被终止。通常，后台进程会有很多个在运行,所以他们维护一个LRU最近使用程序列表来保证经常运行的activity能最后一个被终止。如果一个activity正确的实现了生命周期的方法，并且保存它当前状态，杀死这些进程将不会影响到用户体验。

5 一个空线程没有运行任何可用应用程序组，保留他们的唯一原因是为了设立一个缓存机制，来加快组件启动的时间。系统经常杀死这些内存来平衡系统的整个系统的资源，进程缓存和基本核心缓存之间的资源。
Android把进程里优先级最高的activity或服务，作为这个进程的优先级。例如，一个进程拥有一个服务和一个可见的activity，那么这个进程将会被定义为可见进程，而不是服务进程。

此外，如果别的进程依赖某一个进程的话，那么被依赖的进程会提高优先级。一个进程服务于另一个进程，那么提供服务的进程不会低于获得服务的进程。例如，如果进程A的一个内容提供商服务于进程B的一个客户端，或者进程A的一个service被进程B的一个组件绑定，那么进程A至少拥有和进程B一样的优先级，或者更高。

因为一个运行服务的进程的优先级高于运行后台activity的进程，一个activity会准备一个长时间运行的操作来启动一个服务，而不是启动一个线程–尤其是这个操作可能会拖垮这个activity。例如后台播放音乐的同时，通过照相机向服务器发送一张照片，启动一个服务会保证这个操作至少运行在service 进程的优先级下，无论这个activity发生了什么，广播接收者应该作为一个空服务而不是简单的把耗时的操作单独放在一个线程里。

 

【补充】http://blog.csdn.net/p106786860/article/details/17885115 ：intentservice的使用

关于AIDLservice的binder写法还有：（参考：http://blog.csdn.net/p106786860/article/details/17733223）

  1. /**
  2. * 继承Stub,也就是实现了ICat接口，并实现了IBinder接口
  3. *
  4. * @author pengcx
  5. *
  6. */
  7. public class CatBinder extends Stub {
  8. @Override
  9. public String getColor() throws RemoteException {
  10. return color;
  11. }
  12. @Override
  13. public double getWeight() throws RemoteException {
  14. return weight;
  15. }
  16. }
上一篇：Business talking in English


下一篇：C#入门经典第八章面向对象编程-3-Windows应用程序中的OOP