Android四大组件之Service(学习笔记)

Service的分类

按照运行地点来分类

 

类别 区别  优点 缺点   应用
本地服务(Local) 该服务依附在主进程上,  服务依附在主进程上而不是独立的进程,这样在一定程度上节约了资源,另外Local服务因为是在同一进程因此不需要IPC,也不需要AIDL。相应bindService会方便很多。  主进程被Kill后,服务便会终止。  非常常见的应用如:HTC的音乐播放服务,天天动听音乐播放服务。
远程服务(Remote) 该服务是独立的进程,  服务为独立的进程,对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程,因此在Activity所在进程被Kill的时候,该服务依然在运行,不受其他进程影响,有利于为多个进程提供服务具有较高的灵活性。  该服务是独立的进程,会占用一定资源,并且使用AIDL进行IPC稍微麻烦一点。  一些提供系统服务的Service,这种Service是常驻的。

按照运行类型来分类

 

类别 区别 应用
前台服务 会在通知一栏显示 ONGOING 的 Notification, 当服务被终止的时候,通知一栏的 Notification 也会消失,这样对于用户有一定的通知作用。常见的如音乐播放服务。
后台服务 默认的服务即为后台服务,即不会在通知一栏显示 ONGOING 的 Notification。 当服务被终止的时候,用户是看不到效果的。某些不需要运行或终止提示的服务,如天气更新,日期同步,邮件同步等。

 

按照使用方式来分类

类别 区别
startService 启动的服务 主要用于启动一个服务执行后台任务,不进行通信。停止服务使用stopService
bindService 启动的服务

该方法启动的服务要进行通信。停止服务使用unbindService

2、Service 与 Thread 的区别

  

很多时候,你可能会问,为什么要用 Service,而不用 Thread 呢,因为用 Thread 是很方便的,比起 Service 也方便多了,下面我详细的来解释一下。

 

1). Thread:Thread 是程序执行的最小单元,它是分配CPU的基本单位。可以用 Thread 来执行一些异步的操作。

2). Service:Service 是android的一种机制,当它运行的时候如果是Local Service,那么对应的 Service 是运行在主进程的 main 线程上的。如:onCreate,onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service,那么对应的 Service 则是运行在独立进程的 main 线程上。因此请不要把 Service 理解成线程,它跟线程半毛钱的关系都没有!

  

既然这样,那么我们为什么要用 Service 呢?其实这跟 android 的系统机制有关,我们先拿 Thread 来说。Thread 的运行是独立于 Activity 的,也就是说当一个 Activity 被 finish 之后,如果你没有主动停止 Thread 或者 Thread 里的 run 方法没有执行完毕的话,Thread 也会一直执行。因此这里会出现一个问题:当 Activity 被 finish 之后,你不再持有该 Thread 的引用。另一方面,你没有办法在不同的 Activity 中对同一 Thread 进行控制。

  

举个例子:如果你的 Thread 需要不停地隔一段时间就要连接服务器做某种同步的话,该 Thread 需要在 Activity 没有start的时候也在运行。这个时候当你 start 一个 Activity 就没有办法在该 Activity 里面控制之前创建的 Thread。因此你便需要创建并启动一个 Service ,在 Service 里面创建、运行并控制该 Thread,这样便解决了该问题(因为任何 Activity 都可以控制同一 Service,而系统也只会创建一个对应 Service 的实例)。

  

因此你可以把 Service 想象成一种消息服务,而你可以在任何有 Context 的地方调用 Context.startService、Context.stopService、Context.bindService,Context.unbindService,来控制它,你也可以在 Service 里注册 BroadcastReceiver,在其他地方通过发送 broadcast 来控制它,当然这些都是 Thread 做不到的。

  

3、Service的生命周期

 

onCreate  onStart  onDestroy  onBind 

1). 被启动的服务的生命周期:如果一个Service被某个Activity 调用 Context.startService 方法启动,那么不管是否有Activity使用bindService绑定或unbindService解除绑定到该Service,该Service都在后台运行。如果一个Service被startService 方法多次启动,那么onCreate方法只会调用一次,onStart将会被调用多次(对应调用startService的次数),并且系统只会创建Service的一个实例(因此你应该知道只需要一次stopService调用)。该Service将会一直在后台运行,而不管对应程序的Activity是否在运行,直到被调用stopService,或自身的stopSelf方法。当然如果系统资源不足,android系统也可能结束服务。

 

2). 被绑定的服务的生命周期:如果一个Service被某个Activity 调用 Context.bindService 方法绑定启动,不管调用 bindService 调用几次,onCreate方法都只会调用一次,同时onStart方法始终不会被调用。当连接建立之后,Service将会一直运行,除非调用Context.unbindService 断开连接或者之前调用bindService 的 Context 不存在了(如Activity被finish的时候),系统将会自动停止Service,对应onDestroy将被调用。

 

3). 被启动又被绑定的服务的生命周期:如果一个Service又被启动又被绑定,则该Service将会一直在后台运行。并且不管如何调用,onCreate始终只会调用一次,对应startService调用多少次,Service的onStart便会调用多少次。调用unbindService将不会停止Service,而必须调用 stopService 或 Service的 stopSelf 来停止服务。

 

4). 当服务被停止时清除服务:当一个Service被终止(1、调用stopService;2、调用stopSelf;3、不再有绑定的连接(没有被启动))时,onDestroy方法将会被调用,在这里你应当做一些清除工作,如停止在Service中创建并运行的线程。

 

特别注意:

1、你应当知道在调用 bindService 绑定到Service的时候,你就应当保证在某处调用 unbindService 解除绑定(尽管 Activity 被 finish 的时候绑定会自      动解除,并且Service会自动停止);

2、你应当注意 使用 startService 启动服务之后,一定要使用 stopService停止服务,不管你是否使用bindService; 

3、同时使用 startService 与 bindService 要注意到,Service 的终止,需要unbindService与stopService同时调用,才能终止 Service,不管 startService 与 bindService 的调用顺序,如果先调用 unbindService 此时服务不会自动终止,再调用 stopService 之后服务才会停止,如果先调用 stopService 此时服务也不会终止,而再调用 unbindService 或者 之前调用 bindService 的 Context 不存在了(如Activity 被 finish 的时候)之后服务才会自动停止;

4、当在旋转手机屏幕的时候,当手机屏幕在“横”“竖”变换时,此时如果你的 Activity 如果会自动旋转的话,旋转其实是 Activity 的重新创建,因此旋转之前的使用 bindService 建立的连接便会断开(Context 不存在了),对应服务的生命周期与上述相同。

5、在 sdk 2.0 及其以后的版本中,对应的 onStart 已经被否决变为了 onStartCommand,不过之前的 onStart 任然有效。这意味着,如果你开发的应用程序用的 sdk 为 2.0 及其以后的版本,那么你应当使用 onStartCommand 而不是 onStart。

在什么情况下使用 startService 或 bindService 或 同时使用startService 和 bindService

如果你只是想要启动一个后台服务长期进行某项任务那么使用 startService 便可以了。如果你想要与正在运行的 Service 取得联系,那么有两种方法,一种是使用 broadcast ,另外是使用 bindService ,前者的缺点是如果交流较为频繁,容易造成性能上的问题,并且 BroadcastReceiver 本身执行代码的时间是很短的(也许执行到一半,后面的代码便不会执行),而后者则没有这些问题,因此我们肯定选择使用 bindService(这个时候你便同时在使用 startService 和 bindService 了,这在 Activity 中更新 Service 的某些运行状态是相当有用的)。另外如果你的服务只是公开一个远程接口,供连接上的客服端(android 的 Service 是C/S架构)远程调用执行方法。这个时候你可以不让服务一开始就运行,而只用 bindService ,这样在第一次 bindService 的时候才会创建服务的实例运行它,这会节约很多系统资源,特别是如果你的服务是Remote Service,那么该效果会越明显(当然在 Service 创建的时候会花去一定时间,你应当注意到这点)。

利用Service做一个Demo,实现模拟音乐播放器的播放,上下曲的功能。

public class Mybindservice extends Service {
    @Override
    public void onCreate() {
        super.onCreate();
    }
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {

        return new MyBinder();
    }
    /*
    * Ibinder接口会包含程序的数据,而且这个IBinder接口不能直接用
    * Android已经为开发者写好了一个类————Bind类,已经继承了Ibinder接口
    * 只需要去重写一个类,继承Bind类
    * 然后将其作为Ibind的参数返回
    * */
    public class MyBinder extends Binder{
        public Mybindservice getService(){
            return Mybindservice.this;
        }
    }
    @Override
    public void unbindService(ServiceConnection conn) {
        super.unbindService(conn);
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
    }
    public void play(){
        Log.i("info","PLAY");
    }
    public void pause(){
        Log.i("info","pause");
    }
    public void previous(){
        Log.i("info","previous");
    }
    public void next(){
        Log.i("info","next");
    }
}

在这之中写入方法play,pause等模拟音乐播放器的启停。通过调用Service的程序来实现启停的功能

在Activity的代码之中

public class MainActivity extends AppCompatActivity {
    Intent intent;
    Intent intent2;
    Mybindservice service;
    ServiceConnection conn=new ServiceConnection() {
        //当服务跟启动源连接的时候 会自动回调
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            service=((Mybindservice.MyBinder)iBinder).getService();
        }
        //当服务跟启动源断开的时候 会自动回调
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            //得到服务对象

        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void do_Click(View v){
        switch (v.getId()){
            case R.id.button:
                intent=new Intent(MainActivity.this,MyStartService.class);
                startService(intent);
                break;
            case R.id.button2:
                stopService(intent);
                break;
            case R.id.button3:
                intent2=new Intent(MainActivity.this,Mybindservice.class);
                bindService(intent2,conn, Service.BIND_AUTO_CREATE);
                break;
            case R.id.button8:
                unbindService(conn);
                break;
            case R.id.button4:
                service.play();
                break;
            case R.id.button5:
                service.next();
                break;
            case R.id.button6:
                service.previous();
                break;
            case R.id.button7:
                service.pause();
                break;

        }
    }
    //调用onDestroy方法来停止Service和解绑Service
    @Override
    protected void onDestroy() {
        super.onDestroy();
        stopService(intent2);
        unbindService(conn);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        return true;
        // Inflate the menu; this adds items to the action bar if it is present.

    }
}

 放入一个Demo模仿利用Service来开启系统的网路,wifi,同时也应该注意要在Mainifest中注册使用者权限(User—permission)

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        LayoutInflater layoutInflater= (LayoutInflater) MainActivity.this.getSystemService(LAYOUT_INFLATER_SERVICE);
        View view=layoutInflater.inflate(R.layout.activity_main,null);
        setContentView(view);
    }
    public void onClick(View view){
        switch (view.getId()){
            case R.id.button:
            if(isInternetConnected(MainActivity.this)){
                Toast.makeText(MainActivity.this,"网络连接", Toast.LENGTH_LONG).show();
            }
                Toast.makeText(MainActivity.this,"网络未连接", Toast.LENGTH_LONG).show();
                break;
            case R.id.button2:
                isWifiConnected(MainActivity.this);
                break;
        }

    }
    public boolean isInternetConnected(Context context){
        if(context!=null){
            //获取网络服务
            ConnectivityManager mConnectivityManager= (ConnectivityManager) context.getSystemService(CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo= mConnectivityManager.getActiveNetworkInfo();
            if(networkInfo!=null){
                networkInfo.isAvailable();
            }
        }
        return false;
    }
    public boolean isWifiConnected(Context context){
        //获取wifi服务
        WifiManager wifiManager= (WifiManager) context.getSystemService(WIFI_SERVICE);
        if(wifiManager.isWifiEnabled()){
            wifiManager.setWifiEnabled(false);
            Toast.makeText(context,"wifi打开",Toast.LENGTH_LONG).show();
            return true;
        }
        wifiManager.setWifiEnabled(true);
        Toast.makeText(context,"wifi关闭",Toast.LENGTH_LONG).show();
        return false;
    }
}

 

posted @ 2016-10-30 21:17  EdwardRu  阅读(187)  评论(0编辑  收藏  举报