Android四大组件之Service的介绍

最新推荐文章于 2023-12-27 15:02:42 发布

爱dy

最新推荐文章于 2023-12-27 15:02:42 发布

阅读量2.7k

点赞数 1

分类专栏： android 四大组件文章标签： Service Android四大组件前台Service Service生命周期

本文链接：https://blog.csdn.net/qq_33748378/article/details/52315624

版权

android 四大组件专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Service的基本认识

Service是一个可以在后台执行长时间运行操作而不使用用户界面的应用组件.Service可由其他应用组件启动,而且即使用户切换到其他应用,Service仍将在后台继续运行.Service主要用于在后台处理一些耗时的逻辑,或者去执行某些需要长期运行的任务.必要的时候我们甚至可以在程序退出的情况下,让Service在后台继续保持运行状态.
Service和Activity很相似,但是区别在于:Service一直在后台运行,没有用户界面,所以不会到前台,如果Service被启动起来,就和Activity一样,具有自己的声明周期.另外,需要注意的是,Service和Thread不是一个意思,不要被Service的后台概念所迷惑.实际上Service并不会自动开启线程,所有的代码都是默认运行在主线程中的.因此,我们需要在Service的内部手动创建子线程,并在这里执行具体的任务,否则可能造成ANR的问题.

Service的形式

Service基本上分为两种形式:

Started(启动的)

当应用组件（如 Activity）通过调用 startService() 启动Service时,Service即处于“启动”状态.一旦启动,Service即可在后台无限期运行,即使启动Service的组件已被销毁也不受影响.通常,一个开启的Service执行单一操作并且不会给调用者返回结果.例如,它可能通过网络下载或上传文件.操作完成后,Service会自行停止运行.一个比较形象的比喻startService,//这种方式，就是说：“起来，快去干活，干完活就自己滚蛋，不用回来了”。

Bound(绑定的)

当应用组件通过调用 bindService() 绑定到Service时,Service即处于“绑定”状态.一个绑定的Service提供客户端/服务器接口允许组件和Service交互,甚至跨进程操作使用进行间通信（IPC）.仅当与另一个应用组件绑定时,绑定服务才会运行.多个组件可以同时绑定到该服务,但全部取消绑定后,该服务即会被销毁.一个形象的比喻bindService，//这种方式，就是说：“起来，快去干活，有事电话联系”。

Service的使用

先使用startService()启动Service。

新建一个MyService继承Service，并重写一些所需方法

package com.servicedemo;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

/**
 * Created by YK on 2016/8/26.
 */
public class MyService extends Service {
    //当其他组件调用bindService()方法请求绑定Service时，该方法被回调。（默认为null）
    @Override
    public IBinder onBind(Intent intent) {
        Log.e("kaka", "onBind");
        return null;
    }
    //当Service第一次创建时，回调该方法（只一次）。
    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("kaka", "onCreate");
    }
    //当其他组件调用startService()方法请求启动Service时，该方法被回调（每次）。
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e("kaka", "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }
    //当Service被销毁时回调，在该方法中应清除一些占用的资源。
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e("kaka", "onDestroy");
    }
}

Service是Android四大基本组件之一，那么就必须在AndroidManifest.xml中注册

<span style="color:#2f2f2f;"> <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        </span><span style="color:#ff0000;"><service android:name=".MyService" /></span><span style="color:#2f2f2f;">
    </application></span>

在MainActivity中加入启动Service和停止Service的方法

<span style="color:#2f2f2f;">package com.servicedemo;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private Button mStartService, mStopService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        mStartService.setOnClickListener(this);
        mStopService.setOnClickListener(this);
    }

    private void initView() {
        mStartService = (Button) findViewById(R.id.start);
        mStopService = (Button) findViewById(R.id.stop);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.start:
                </span><span style="color:#ff0000;">Intent startIntent = new Intent(this, MyService.class);
                startService(startIntent);</span><span style="color:#2f2f2f;">
                break;
            case R.id.stop:
                </span><span style="color:#ff0000;">Intent stopIntent = new Intent(this, MyService.class);
                stopService(stopIntent);</span><span style="color:#2f2f2f;">
                break;
            default:
                break;
        }
    }
}</span>

运行结果及说明：

点击启动服务按钮，运行结果：

在上面基础之上点击启动服务按钮两次：

按返回键后再次点击启动服务按钮：

在上面基础上再点两次启动服务按钮：

点击停止服务：

重新进入应用，点击启动服务按钮：

结论： Service只有在第一次启动的时候才会调用onCreate()方法，此后再次点击Start Service按钮只会执行onStartCommand()方法，并不会再启动一个服务。

如何让Activity与Service产生“羁绊"呢？这里就需要使用之前MyService中没有使用的方法onBind()了，这个方法就是用于与Activity建立关联的。先修改MyService的代码，新增了一个MyBinder类继承自Binder类，MyBinder中添加了一个doSomething()方法用于执行你要执行的后台任务。

使用bindService()方法启动Service。

MyService代码如下：

package com.servicedemo;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

/**
 * Created by YK on 2016/8/26.
 */
public class MyService extends Service {
    //当其他组件调用bindService()方法请求绑定Service时，该方法被回调。（默认为null）
    @Override
    public IBinder onBind(Intent intent) {
        Log.e("kaka", "onBind");
        return new MyBinder();
    }

    //当Service第一次创建时，回调该方法（只一次）。
    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("kaka", "onCreate");
    }

    //当其他组件调用startService()方法请求启动Service时，该方法被回调（每次）。
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e("kaka", "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

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

    //当Service被销毁时回调，在该方法中应清除一些占用的资源。
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e("kaka", "onDestroy");
    }

    class MyBinder extends Binder {
        public void doSomething(){
            Log.e("kaka","doSomething");
        }
    }
}

修改MainActivity中的代码，让MainActivity和MyService之间建立关联：

<span style="color:#2f2f2f;">package com.servicedemo;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private Button mStartService, mStopService;
    private MyService.MyBinder myBinder;
    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.e("kaka", "onServiceConnected");
            myBinder = (MyService.MyBinder) service;
            myBinder.doSomething();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("kaka", "onServiceDisconnected");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        mStartService.setOnClickListener(this);
        mStopService.setOnClickListener(this);
    }

    private void initView() {
        mStartService = (Button) findViewById(R.id.start);
        mStopService = (Button) findViewById(R.id.stop);
    }


    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.start:
                //这里传入BIND_AUTO_CREATE，表示在Activity和Service关联后自动创建Service，
                //</span><span style="color:#ff0000;">这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。</span><span style="color:#2f2f2f;">
                Intent startIntent = new Intent(this, MyService.class);
                bindService(startIntent, conn, BIND_AUTO_CREATE);
                break;
            case R.id.stop:
                //如果没有绑定服务就执行unbindService是会报错， java.lang.IllegalArgumentException: Service not registered:
                unbindService(conn);
                break;
            default:
                break;
        }
    }
}
</span>

运行结果及说明：

点击绑定服务：

再次点击绑定服务：不会打印任何log

没有点击解绑的情况下按返回键退出打印log：

可以看出会提示没有解绑，但是仍然会执行onUnbind()和onDestroy()方法。

解决的办法就是：

@Override
    protected void onDestroy(){
        super.onDestroy();
        unbindService(conn);
    }

点击绑定服务后再点击解绑：

我们可以知道，多次点击绑定服务按钮，并不会重复执行ServiceConnection中的onServiceConnected()方法。

如果击了Start Service按钮，又点击了Bind Service按钮又是什么情况呢？

这时无论单独点击停止按钮还是解绑服务按钮，Service都不会被销毁，必须要将两个按钮都点击一下，Service才会被销毁，也就是调用onDestroy()方法。所以，一个Service必须要在既没有和任何Activity关联又处于停止状态的时候才会被销毁。

Service生命周期总结

不同的启动方式，Service回调的生命周期方法也不一样。

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

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

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

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

注意：1、使用startService的时候，一般在onStartCommand()中写主要的逻辑代码，但是Service运行在主线程中，所以Service本身不能做耗时操作。如果做耗时操作或访问网络可以使用异步任务、子线程、Loader等来处理。

特别注意：
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。

Service和Thread的区别

都是后台运行，那么Service和Thread的选择就会迷惑不少人，什么时候用Service？什么时候用Thread？
区别：

Service是运行在主线程里的，而Thread是开辟新的线程。(即如果在Service里编写了非常耗时的代码，程序必定会出现ANR的)

Service后台是指它的运行完全不依赖UI，即使Activity被销毁，或者程序被关闭，只要进程还在，Service就可以运行。（耗时的操作可以在Service中创建一个子线程去处理即可）

既然都要创建子线程，为什么不在Activity中创建而是到Service中？
这是因为Activity很难对Thread进行控制，当Activity被销毁后，就无法获取到Thread的实例了，而且在1Activity中创建的线程，在2Activity中是无法对其进行操作的。但Service不受这些约束，只要进程还在，Activity即使被销毁了，也能对子线程进行控制。

前台Service

Service基本都是后台运行的，既然后台运行有时候希望它能一直运行，比如时钟，或者需要实时运行的服务。但是Service的系统优先级还是比较低的，当系统出现了内存不足的情况，还是有可能回收掉正在后台运行的Service，Service如果要防止尽可能不被系统杀掉，需要设置为在前台运行。就像QQ一样，会在系统状态栏一直显示一个图标信息。
由于设置前台运行service的方法在2.0之前和2.0之后有所变化。所以需要根据不同的版本进行区分；或者完全使用反射机制来处理，这样只要有相应的方法就可以使用，否则使用其他版本的方法。修改MyService中的代码为：

待续。。。

IntentService

待续。。。

拥有service的进程具有较高的优先级

　　官方文档告诉我们，Android系统会尽量保持拥有service的进程运行，只要在该service已经被启动(start)或者客户端连接(bindService)到它。当内存不足时，需要保持，拥有service的进程具有较高的优先级。

如果service正在调用onCreate,onStartCommand或者onDestory方法，那么用于当前service的进程则变为前台进程以避免被killed。
如果当前service已经被启动(start)，拥有它的进程则比那些用户可见的进程优先级低一些，但是比那些不可见的进程更重要，这就意味着service一般不会被killed.
如果客户端已经连接到service (bindService),那么拥有Service的进程则拥有最高的优先级，可以认为service是可见的。
如果service可以使用startForeground(int, Notification)方法来将service设置为前台状态，那么系统就认为是对用户可见的，并不会在内存不足时killed。
如果有其他的应用组件作为Service,Activity等运行在相同的进程中，那么将会增加该进程的重要性。

参考资料：

官方文档：https://developer.android.com/reference/android/app/Service.html#

Android创建前台运行的Service：http://blog.csdn.net/ameyume/article/details/9150755