zoukankan      html  css  js  c++  java

  • android关键组件service服务(一)

    一、 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 

    startService(new Intent(LoginActivity.this, XXService.class));

    假设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
    在Service每一次的开启关闭过程中，仅仅有onStart可被多次调用(通过多次startService调用)，其它onCreate，onBind，onUnbind，onDestory在一个生命周期中仅仅能被调用一次。

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

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

    三、 Service生命周期 

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

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

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

    它能够通过Service.stopSelf()方法或者Service.stopSelfResult()方法来停止自己，仅仅要调用一次stopService()方法便能够停止服务，不管调用了多少次的启动服务方法。

           


    四、 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. }  


    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. }  

    AndroidManifest.xml

    注冊activity

    [css] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. <activity  
    2.     android:name=".service.PlayMusicService"  
    3.     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>  


    五、 代码解析

    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操作系统尝试尽可能长时间的保持应用的进程，但当可用内存非常低时终于要移走一部分进程。如何确定那些程序能够执行，那些要被销毁，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的一个client，或者进程A的一个service被进程B的一个组件绑定，那么进程A至少拥有和进程B一样的优先级，或者更高。

    由于一个执行服务的进程的优先级高于执行后台activity的进程，一个activity会准备一个长时间执行的操作来启动一个服务，而不是启动一个线程–尤其是这个操作可能会拖垮这个activity。比如后台播放音乐的同一时候，通过照相机向server发送一张照片，启动一个服务会保证这个操作至少执行在service 进程的优先级下，不管这个activity发生了什么，广播接收者应该作为一个空服务而不是简单的把耗时的操作单独放在一个线程里。 
  • 相关阅读:
    SpringMVC @RequestBody请求参数在postman中的请求
    git rm -r --cached 去掉已经托管在git上的文件
    shiro源码解析--------欢迎指出错误地方，还有一起讨论一下ShiroFilterFactoryBean配置过滤URL规则
    如何用Tomcat部署前端静态文件
    用HTML 格式导出Excel
    csv和excel的区别
    使用HttpOnly提升Cookie安全性
    asp.net core 如何在Controller获取配置文件的值
    Find Out What Your Entity Framework Query Is Really Doing
    鸡汤
  • 原文地址：https://www.cnblogs.com/gcczhongduan/p/4184787.html
Copyright © 2011-2022 走看看