Android Service 服务

时间  2019-11-10
标签 android service 服务 栏目 Android 繁體版
原文   原文链接

1、 Service简介css

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

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


2、 Service启动流程缓存

context.startService() 启动流程：服务器

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


若是Service尚未运行，则android先调用onCreate()，而后调用onStart()；app

若是Service已经运行，则只调用onStart()，因此一个Service的onStart方法可能会重复调用屡次。 ide

若是stopService的时候会直接onDestroy，若是是调用者本身直接退出而没有调用stopService的话，Service会一直在后台运行，该Service的调用者再启动起来后能够经过stopService关闭Service。函数

因此调用startService的生命周期为：onCreate --> onStart (可屡次调用) --> onDestroyoop


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在一个生命周期中只能被调用一次。

 


3、 Service生命周期 

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

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

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

它能够经过Service.stopSelf()方法或者Service.stopSelfResult()方法来中止本身，只要调用一次stopService()方法即可以中止服务，不管调用了多少次的启动服务方法。


4、 Service示例

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

Activity

[java] view plaincopyprint?在CODE上查看代码片派生到个人代码片

  1. public class PlayMusicService extends Activity implements OnClickListener {  

  2.   

  3.     private Button playBtn;  

  4.     private Button stopBtn;  

  5.     private Button pauseBtn;  

  6.     private Button exitBtn;  

  7.     private Button closeBtn;  

  8.   

  9.     private Intent intent;  

  10.       

  11.     @Override  

  12.     public void onCreate(Bundle savedInstanceState) {  

  13.         super.onCreate(savedInstanceState);  

  14.         setContentView(R.layout.music_service);  

  15.   

  16.         playBtn = (Button) findViewById(R.id.play);  

  17.         stopBtn = (Button) findViewById(R.id.stop);  

  18.         pauseBtn = (Button) findViewById(R.id.pause);  

  19.         exitBtn = (Button) findViewById(R.id.exit);  

  20.         closeBtn = (Button) findViewById(R.id.close);  

  21.           

  22.         playBtn.setOnClickListener(this);  

  23.         stopBtn.setOnClickListener(this);  

  24.         pauseBtn.setOnClickListener(this);  

  25.         exitBtn.setOnClickListener(this);  

  26.         closeBtn.setOnClickListener(this);  

  27.   

  28.     }  

  29.   

  30.     @Override  

  31.     public void onClick(View v) {  

  32.         int op = -1;  

  33.         intent = new Intent("com.homer.service.musicService");  

  34.   

  35.         switch (v.getId()) {  

  36.         case R.id.play:                             // play music   

  37.             op = 1;  

  38.             break;  

  39.         case R.id.stop:                             // stop music   

  40.             op = 2;  

  41.             break;  

  42.         case R.id.pause:                            // pause music   

  43.             op = 3;  

  44.             break;  

  45.         case R.id.close:                            // close activity   

  46.             this.finish();  

  47.             break;  

  48.         case R.id.exit:                             // stopService   

  49.             op = 4;  

  50.             stopService(intent);  

  51.             this.finish();  

  52.             break;  

  53.         }  

  54.   

  55.         Bundle bundle = new Bundle();  

  56.         bundle.putInt("op", op);  

  57.         intent.putExtras(bundle);  

  58.           

  59.         startService(intent);                           // startService   

  60.     }  

  61.       

  62.     @Override  

  63.     public void onDestroy(){  

  64.         super.onDestroy();  

  65.   

  66.         if(intent != null){  

  67.             stopService(intent);  

  68.         }  

  69.     }  

  70. }  

public class PlayMusicService extends Activity implements OnClickListener {

 private Button playBtn;
 private Button stopBtn;
 private Button pauseBtn;
 private Button exitBtn;
 private Button closeBtn;

 private Intent intent;
 
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.music_service);

 playBtn = (Button) findViewById(R.id.play);
 stopBtn = (Button) findViewById(R.id.stop);
 pauseBtn = (Button) findViewById(R.id.pause);
 exitBtn = (Button) findViewById(R.id.exit);
 closeBtn = (Button) findViewById(R.id.close);
 
 playBtn.setOnClickListener(this);
 stopBtn.setOnClickListener(this);
 pauseBtn.setOnClickListener(this);
 exitBtn.setOnClickListener(this);
 closeBtn.setOnClickListener(this);

 }

 @Override
 public void onClick(View v) {
 int op = -1;
 intent = new Intent("com.homer.service.musicService");

 switch (v.getId()) {
 case R.id.play: // play music
 op = 1;
 break;
 case R.id.stop: // stop music
 op = 2;
 break;
 case R.id.pause: // pause music
 op = 3;
 break;
 case R.id.close: // close activity
 this.finish();
 break;
 case R.id.exit: // stopService
 op = 4;
 stopService(intent);
 this.finish();
 break;
 }

 Bundle bundle = new Bundle();
 bundle.putInt("op", op);
 intent.putExtras(bundle);
 
 startService(intent); // startService
 }
 
 @Override
 public void onDestroy(){
 super.onDestroy();

 if(intent != null){
 stopService(intent);
 }
 }
}


Service

[java] view plaincopyprint?在CODE上查看代码片派生到个人代码片

  1. public class MusicService extends Service {  

  2.     private static final String TAG = "MyService";  

  3.       

  4.     private MediaPlayer mediaPlayer;  

  5.   

  6.     @Override  

  7.     public IBinder onBind(Intent arg0) {  

  8.         return null;  

  9.     }  

  10.   

  11.     @Override  

  12.     public void onCreate() {  

  13.         Log.v(TAG, "onCreate");  

  14.         Toast.makeText(this, "show media player", Toast.LENGTH_SHORT).show();  

  15.   

  16.         if (mediaPlayer == null) {  

  17.             mediaPlayer = MediaPlayer.create(this, R.raw.tmp);  

  18.             mediaPlayer.setLooping(false);  

  19.         }  

  20.     }  

  21.   

  22.     @Override  

  23.     public void onDestroy() {  

  24.         Log.v(TAG, "onDestroy");  

  25.         Toast.makeText(this, "stop media player", Toast.LENGTH_SHORT);  

  26.         if (mediaPlayer != null) {  

  27.             mediaPlayer.stop();  

  28.             mediaPlayer.release();  

  29.         }  

  30.     }  

  31.   

  32.     @Override  

  33.     public void onStart(Intent intent, int startId) {  

  34.         Log.v(TAG, "onStart");  

  35.         if (intent != null) {  

  36.             Bundle bundle = intent.getExtras();  

  37.             if (bundle != null) {  

  38.                 int op = bundle.getInt("op");  

  39.                 switch (op) {  

  40.                 case 1:  

  41.                     play();  

  42.                     break;  

  43.                 case 2:  

  44.                     stop();  

  45.                     break;  

  46.                 case 3:  

  47.                     pause();  

  48.                     break;  

  49.                 }  

  50.             }  

  51.         }  

  52.     }  

  53.   

  54.     public void play() {  

  55.         if (!mediaPlayer.isPlaying()) {  

  56.             mediaPlayer.start();  

  57.         }  

  58.     }  

  59.   

  60.     public void pause() {  

  61.         if (mediaPlayer != null && mediaPlayer.isPlaying()) {  

  62.             mediaPlayer.pause();  

  63.         }  

  64.     }  

  65.   

  66.     public void stop() {  

  67.         if (mediaPlayer != null) {  

  68.             mediaPlayer.stop();  

  69.             try {  

  70.                 mediaPlayer.prepare();  // 在调用stop后若是须要再次经过start进行播放,须要以前调用prepare函数   

  71.             } catch (IOException ex) {  

  72.                 ex.printStackTrace();  

  73.             }  

  74.         }  

  75.     }  

  76. }  

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

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

 @Override
 public void onCreate() {
 Log.v(TAG, "onCreate");
 Toast.makeText(this, "show media player", Toast.LENGTH_SHORT).show();

 if (mediaPlayer == null) {
 mediaPlayer = MediaPlayer.create(this, R.raw.tmp);
 mediaPlayer.setLooping(false);
 }
 }

 @Override
 public void onDestroy() {
 Log.v(TAG, "onDestroy");
 Toast.makeText(this, "stop media player", Toast.LENGTH_SHORT);
 if (mediaPlayer != null) {
 mediaPlayer.stop();
 mediaPlayer.release();
 }
 }

 @Override
 public void onStart(Intent intent, int startId) {
 Log.v(TAG, "onStart");
 if (intent != null) {
 Bundle bundle = intent.getExtras();
 if (bundle != null) {
 int op = bundle.getInt("op");
 switch (op) {
 case 1:
 play();
 break;
 case 2:
 stop();
 break;
 case 3:
 pause();
 break;
 }
 }
 }
 }

 public void play() {
 if (!mediaPlayer.isPlaying()) {
 mediaPlayer.start();
 }
 }

 public void pause() {
 if (mediaPlayer != null && mediaPlayer.isPlaying()) {
 mediaPlayer.pause();
 }
 }

 public void stop() {
 if (mediaPlayer != null) {
 mediaPlayer.stop();
 try {
 mediaPlayer.prepare(); // 在调用stop后若是须要再次经过start进行播放,须要以前调用prepare函数
 } catch (IOException ex) {
 ex.printStackTrace();
 }
 }
 }
}


AndroidManifest.xml

注册activity

[css] view plaincopyprint?在CODE上查看代码片派生到个人代码片

  1. <activity  

  2.     android:name=".service.PlayMusicService"  

  3.     android:label="@string/app_name" />  

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

注册service

[css] view plaincopyprint?在CODE上查看代码片派生到个人代码片

  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>  

        <service
            android:name=".service.MusicService"
            android:enabled="true" >
            <intent-filter>
                <action android:name="com.homer.service.musicService" />
            </intent-filter>
        </service>



5、 代码解析

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

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

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

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

startService(intent);

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

onCreate()，  建立mediaPlayer

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

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

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

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

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


源码下载



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

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发生了什么，广播接收者应该做为一个空服务而不是简单的把耗时的操做单独放在一个线程里。 

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程