Service的理解和使用

Posted 2020-07-07 llayjun

首先推荐一下郭林大神所讲的这一节的博客：http://blog.csdn.net/guolin_blog/article/details/11952435
下面结合我对这一部分的学习，自己做一个小节。
android5.0之后组件必须使用显示intent来启动，如果为隐示的，则设置Intent的包名。intent.setPackage(“com.llay.admin.mydemo”);

一、基本概念

Service是一个应用程序组件，它能够在后台执行一些耗时较长的操作，并且不提供用户界面。服务能被其它应用程序的组件启动，即使用户切换到另外的应用时还能保持后台运行。此外，应用程序组件还能与服务绑定，并与服务进行交互，甚至能进行进程间通信（IPC）。 比如，服务可以处理网络传输、音乐播放、执行文件I/O、或者与content provider进行交互，所有这些都是后台进行的。

二、服务的分类

服务有以下两种基本类型：

Started （这里有一个service的子类IntentService，待会儿单独讲解）
如果一个应用程序组件（比如一个activity）通过调用startService()来启动服务，则该服务就是被“started”了。一旦被启动，服务就能在后台一直运行下去，即使启动它的组件已经被销毁了。
通常，started的服务执行单一的操作并且不会向调用者返回结果。比如，它可以通过网络下载或上传文件。当操作完成后，服务应该自行终止。

Bound
如果一个应用程序组件通过调用bindService()绑定到服务上，则该服务就是被“bound”了。bound服务提供了一个客户端/服务器接口，允许组件与服务进行交互、发送请求、获取结果，甚至可以利用进程间通信（IPC）跨进程执行这些操作。绑定服务的生存期和被绑定的应用程序组件一致。
多个组件可以同时与一个服务绑定，不过所有的组件解除绑定后，服务也就会被销毁。

三、一些回调方法

服务的生命周期图：

为了创建一个服务，你必须新建一个Service的子类（或一个已有Service的子类）。在你的实现代码中，请按需重写一些回调方法，用于对服务生命周期中的关键节点进行处理，以及向组件提供绑定机制。 最重要的需要重写的回调方法包括：

onStartCommand()
当其它组件，比如一个activity，通过调用startService()请求started方式的服务时，系统将会调用本方法。 一旦本方法执行，服务就被启动，并在后台一直运行下去。 如果你的代码实现了本方法，你就有责任在完成工作后通过调用stopSelf()或stopService()终止服务。 （如果你只想提供bind方式，那就不需要实现本方法。）

onBind()
当其它组件需要通过bindService()绑定服务时（比如执行RPC），系统会调用本方法。 在本方法的实现代码中，你必须返回IBinder来提供一个接口，客户端用它来和服务进行通信。 你必须确保实现本方法，不过假如你不需要提供绑定，那就返回null即可。

onCreate()
当服务第一次被创建时，系统会调用本方法，用于执行一次性的配置工作（之前已调用过onStartCommand()或onBind()) 了。如果服务已经运行，则本方法就不会被调用。

onDestroy()
当服务用不上了并要被销毁时，系统会调用本方法。 你的服务应该实现本方法来进行资源的清理工作，诸如线程、已注册的侦听器listener和接收器receiver等等。 这将是服务收到的最后一个调用。

如果组件通过调用startService()（这会导致onStartCommand()的调用）启动了服务，那么服务将一直保持运行，直至自行用stopSelf()终止或由其它组件调用stopService()来终止它。

如果组件调用bindService()来创建服务（那onStartCommand()就不会被调用），则服务的生存期就与被绑定的组件一致。一旦所有客户端都对服务解除了绑定，系统就会销毁该服务。

仅当内存少得可怜、且必须覆盖拥有用户焦点的activity的系统资源时，Android系统才会强行终止一个服务。 如果服务被拥有用户焦点的activity绑定着，则它一般不会被杀死。 如果服务声明为#在前台运行服务（下文讨论），则它几乎永远不会被杀死。 否则，如果服务已被启动并且已运行了很长时间，那么系统将会随时间推移而降低它在后台任务列表中的级别， 此类服务将很有可能会被杀死——如果服务已经启动，那你必须好好设计代码，使其能完美地应付被系统重启的情况。 如果系统杀死了你的服务，只要资源再度够用，系统就会再次启动服务（当然这还取决于onStartCommand()的返回值，下文将会述及）。关于系统可能会在何时销毁服务的详细信息，请参阅进程和线程。

四、代码的实现

注意：Service是Android的四大组件，所以记得在Androidmanifests.xml文件中注册。注意：四大组件只有BroadCast能动态注册。

界面图片：

4、1 Started服务的代码实现

started服务是指其它组件通过调用startService()来启动的服务，这会引发对该服务onStartCommand()方法的调用。

一旦服务被启动started，它就拥有了自己的生命周期，这是独立于启动它的组件的。并且它能够在后台一直运行下去，即使启动它的组件已被销毁 也是如此。 因此，服务应该能够在完成工作后自行终止，通过调用stopSelf()即可，或者由其它组件通过调用stopService()也可以。

诸如activity之类的应用程序组件，可以通过调用startService()启动服务,并传入一个给出了服务和服务所需数据的Intent对象。服务将在onStartCommand()方法中接收到该Intent对象。

举个例子，假定某activity需要把一些数据保存到在线数据库中。此activity可以启动一个守护服务并通过传入startService()一个intent把需要保存的数据发送给该服务。该服务在onStartCommand()内接收intent，连接Internet，再进行数据库事务处理。当事务完成后，服务自行终止，并被系统销毁。

在Activity中代码的方法：

private void initStartedService() {
        final Intent intent = new Intent(ServiceDemoActivity.this, HelloStartedService.class);
        startedService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(startedServiceTAG, "开启服务");
                intent.putExtra("StartedServiceTest", "StartedServiceTest");
                startService(intent);
            }
        });

        stopService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(stopServiceTAG, "手动停止服务");
                stopService(intent);
            }
        });
    }

HelloStartedService.java文件

public class HelloStartedService extends Service {
    private Looper looper;
    private StartedServiceHandler startedServiceHandler;
    public String s;
    public final String TAG = "startedService";

    public HelloStartedService() {
    }

    @Override
    public void onCreate() {
        //这里配置一些信息
        //启动运行服务的线程。
        //请记住我们要创建一个单独的线程，因为服务通常运行于进程的主线程中，可我们不想阻塞主线程。
        //我们还要赋予它后台运行的优先级，以便计算密集的工作不会干扰我们的UI。
        HandlerThread handlerThread = new HandlerThread("StartedService");
        handlerThread.start();
        //获得HandlerThread的Looper队列并用于Handler
        looper = handlerThread.getLooper();
        startedServiceHandler = new StartedServiceHandler(looper);
        Log.e(TAG, "onCreate");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand");
        s = intent.getStringExtra("StartedServiceTest");
        //对于每一个启动请求，都发送一个消息来启动一个处理
        //同时传入启动ID，以便任务完成后我们知道该终止哪一个请求。
        Message message = startedServiceHandler.obtainMessage();
        message.arg1 = 1;
        startedServiceHandler.sendMessage(message);
        //如果我们被杀死了，那从这里返回之后被重启
        return START_STICKY;

    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG, "onDestroy");
    }

    public class StartedServiceHandler extends Handler {
        public StartedServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            //通常我们在这里执行一些工作，比如下载文件。
            try {
                Log.e(TAG, "开始在服务中处理信息");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //根据startId终止服务，这样我们就不会在处理其它工作的过程中再来终止服务
            //如果组件通过调用startService()（这会导致onStartCommand()的调用）启动了服务，那么服务将一直保持运行，直至自行用stopSelf()终止或由其它组件调用stopService()来终止它。
            //如果组件调用bindService()来创建服务（那onStartCommand()就不会被调用），则服务的生存期就与被绑定的组件一致。一旦所有客户端都对服务解除了绑定，系统就会销毁该服务。
            stopSelf(msg.arg1);
            Log.e(TAG, "startedService处理数据完成后自动停止");
        }
    }


    //不支持绑定，所以我们返回null
    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        return null;
    }
}

注意：我这里在StartedService中，使用了HandlerThread来实现在线程中处理事件。因为这里的服务还是在主线程中的，不能阻塞。

AndroidManifests.xml文件中注册

<service
            android:name="com.llay.admin.service.HelloStartedService"
            android:enabled="true"
            android:exported="true" />

运行图：
打开服务：

关闭服务（完成后自动关闭）：
在处理过程后，有这样一句代码，自动关闭。


关闭服务（手动关闭）：
在按钮点击事件中，手动关闭。

4、1、1 IntentService代码实现

注意：默认情况下，运行服务的进程与应用程序的相同，并且运行在应用程序的主线程中。
因此，如果你的服务要执行计算密集或阻塞的操作，而同时用户又需要与同一个应用程序中的activity进行交互，那么服务将会降低activity的性能。
为了避免对应用程序性能的影响，你应该在服务中启动一个新的线程。

IntentService:异步处理服务，新开一个线程：handlerThread在线程中发消息，然后接受处理完成后，会清理线程，并且关掉服务。
IntentService有以下特点：

（1） 它创建了一个独立的工作线程来处理所有的通过onStartCommand()传递给服务的intents。

（2） 创建了一个工作队列，来逐个发送intent给onHandleIntent()。

（3） 不需要主动调用stopSelft()来结束服务。因为，在所有的intent被处理完后，系统会自动关闭服务。

（4） 默认实现的onBind()返回null

（5） 默认实现的onStartCommand()的目的是将intent插入到工作队列中

Activity中的方法代码：

 private void initIntentService() {
        //Android5.0之后必须使用显示intent来启动
        //Android的四大组件，只有BroadcastReceiver能够动态在AndroidManifests文件中注册
        final Intent intent = new Intent("com.llay.admin.service.action.llay").setPackage("com.llay.admin.mydemo");
        startedIntentService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(startedServiceTAG, "开启Intent服务");
                intent.putExtra("IntentServiceTest", "IntentServiceTest");
                startService(intent);
            }
        });
        stopIntentService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(stopServiceTAG, "手动Intent停止服务");
                stopService(intent);
            }
        });
    }

HelloIntentService.java文件

public class HelloIntentService extends IntentService {

    /**
     * 构造方法是必需的，必须用工作线程名称作为参数
     * 调用父类的[http://developer.android.com/reference/android/app/IntentService.html#IntentService(java.lang.String) IntentService(String)]构造方法。
     */
    public HelloIntentService() {
        super("HelloIntentService");
    }


    /**
     * IntentService从缺省的工作线程中调用本方法，并用启动服务的intent作为参数。
     * 本方法返回后，IntentService将适时终止这个服务。
     */
    @Override
    protected void onHandleIntent(Intent intent) {
        String s = intent.getStringExtra("IntentServiceTest");
        Log.e("IntentServiceTest", s);
    }
}

AndroidManifests.xml文件中注册

<service
            android:name="com.llay.admin.service.HelloIntentService"
            android:enabled="true"
            android:exported="true" />

运行图：
开启Intent服务：

关闭Intent服务（这里和上面started服务一样，可以自动关闭，可以手动关闭）：

注意：这里我们来分析一下Service和IntentService的区别和使用地方。

利用IntentService来实现一个started服务非常简单。 不过，假如你的服务需要多线程运行（而不是通过一个工作队列来处理启动请求），那你可以扩展Service类来完成每个intent的处理。如你所见，它要干的事情比用IntentService时多了很多。不过，因为是自行处理每个onStartCommand()调用，你可以同时处理多个请求。 本例中没有这么去实现，但只要你愿意，你就可以为每个请求创建一个新的线程，并立即运行它们（而不是等待前一个请求处理完毕）。

总结： 在当需要一起在线程（自己开）中处理，则使用Started服务。 在当需要一个一个在线程（自带）中处理，则使用IntentService。

4、2 Bound服务的代码实现

Activity中的方法代码：

private void initBoundService() {
        boundService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(boundServiceTAG, "绑定服务");
                //绑定到LocalService
                Intent intent = new Intent(ServiceDemoActivity.this, HelloBoundService.class);
                bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
                Log.e("BoundServiceTest", "BoundServiceStart");
            }
        });

        unboundService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(unBoundServiceTAG, "手动解除绑定");
                unbindService(serviceConnection);
                mBound = false;
            }
        });

        showNumber.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mBound) {
                    //调用LocalService中的方法。
                    //不过，如果该调用会导致某些操作的挂起，那么调用应该放入单独的线程中进行，
                    //以免降低activity的性能。
                    int num = helloBoundService.getRandomNumber();
                    Toast.makeText(ServiceDemoActivity.this, "number: " + num, Toast.LENGTH_SHORT).show();
                }
            }
        });

        serviceConnection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                //我们已经绑定到LocalService了，对IBinder进行类型转换（cast）并获得LocalService对象的实例
                HelloBoundService.LocalBinder localBinder = (HelloBoundService.LocalBinder) service;
                helloBoundService = localBinder.getHelloBoundService();
                mBound = true;
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                mBound = false;
            }
        };
    }


    //以下是绑定服务的一些回调函数
    @Override
    protected void onStart() {
        super.onStart();
    }

    @Override
    protected void onStop() {
        super.onStop();
        //与服务解除绑定
        if (mBound) {
            unbindService(serviceConnection);
            mBound = false;
        }
        Log.e(unBoundServiceTAG, "自动解除绑定");
    }

HelloBoundService.java文件：

public class HelloBoundService extends Service {
    //给客户端的Binder
    public IBinder mBinder = new LocalBinder();
    //生成随机数
    private final Random mGenerator = new Random();


    /**
     * 用于客户端Binder的类。
     * 因为知道本服务总是运行于与客户端相同的进程中，我们就不需要用IPC进行处理。
     */
    public class LocalBinder extends Binder {
        public HelloBoundService getHelloBoundService() {
            return HelloBoundService.this;
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    /**
     * method for clients
     */
    public int getRandomNumber() {
        return mGenerator.nextInt(100);
    }
}

注意：如果你的服务只用于本地应用程序并且不需要跨进程工作，那你只要实现自己的 Binder
类即可，这样你的客户端就能直接访问服务中的公共方法了。
注意：仅当客户端和服务位于同一个应用程序和进程中，这也是最常见的情况，这种方式才会有用。比如，一个音乐应用需要把一个activity绑定到它自己的后台音乐播放服务上，采用这种方式就会很不错。
以下是设置步骤： 1、在你的服务中，创建一个Binder的实例，其中实现以下三者之一：

• 包含了可供客户端调用的公共方法
• 返回当前Service实例，其中包含了可供客户端调用的公共方法。
• 或者，返回内含服务类的其它类的一个实例，服务中包含了可供客户端调用的公共方法。

2、从回调方法onBind()中返回Binder的该实例。
3、在客户端中，在回调方法onServiceConnected()中接收Binder并用所提供的方法对绑定的服务进行调用。 注意：
服务和客户端之所以必须位于同一个应用程序中，是为了让客户端能够正确转换（cast）返回的对象并调用对象的API。
服务和客户端也必须位于同一个进程中，因为这种方式不能执行任何跨进程的序列化（marshalling）操作。

AndroidManifests.xml文件中注册

<service
            android:name="com.llay.admin.service.HelloBoundService"
            android:enabled="true"
            android:exported="true" />

运行图：
绑定服务：

解絆服务：

五、扩展

创建一个支持绑定的服务时，你必须提供一个 IBinder ，用作客户端和服务间进行通信的编程接口。定义这类接口的方式有三种：

扩展Binder类
如果服务是你的应用程序所私有的，并且与客户端运行于同一个进程中（通常都是如此），你应该通过扩展Binder类来创建你的接口,并从onBind()返回一个它的实例。客户端接收该Binder对象并用它来直接访问Binder甚至Service中可用的公共（public）方法。
如果你的服务只是为你自己的应用程序执行一些后台工作，那这就是首选的技术方案。不用这种方式来创建接口的理由只有一个，就是服务要被其它应用程序使用或者要跨多个进程使用。

使用Messenger
如果你需要接口跨越多个进程进行工作，可以通过Messenger来为服务创建接口。在这种方式下，服务定义一个响应各类消息对象Message的Handler。此Handler是Messenger与客户端共享同一个IBinder的基础，它使得客户端可以用消息对象Message向服务发送指令。此外，客户端还可以定义自己的Message，以便服务能够往回发送消息。
这是执行进程间通信（IPC）最为简便的方式，因为Messenger会把所有的请求放入一个独立进程中的队列，这样你就不一定非要把服务设计为线程安全的模式了。

使用AIDL
Android接口定义语言AIDL（Android Interface Definition Language）完成以下的所有工作：将对象解析为操作系统可识别的原始形态，并将它们跨进程序列化（marshal）以完成IPC。前一个使用Messenger的方式，实际上也是基于AIDL的，它用AIDL作为底层结构。如上所述，Messenger将在一个单独的进程中创建一个包含了所有客户端请求的队列，这样服务每次就只会收到一个请求。可是，如果想让你的服务能同时处理多个请求，那你就可以直接使用AIDL。这种情况下，你的服务必须拥有多线程处理能力，并且是以线程安全的方式编写的。
要直接使用AIDL，你必须创建一个.aidl文件，其中定义了编程的接口。Android SDK工具使用此文件来生成一个抽象类（abstract class），其中实现了接口及对IPC的处理，然后你就可以在自己的服务中扩展该类。

注意：

绝大多数应用程序都不应该用AIDL来创建bound服务，因为这可能需要多线程处理能力并且会让代码变得更为复杂。
因此，AIDL对绝大多数应用程序都不适用，并且本文也不会讨论如何在服务中使用它的内容。如果你确信需要直接使用AIDL，那请参阅 AIDL
文档。