Service的理解和使用

最新推荐文章于 2024-04-06 11:44:38 发布

科克蛙

最新推荐文章于 2024-04-06 11:44:38 发布

阅读量412

点赞数

分类专栏： Android基础技术文章标签： Service

Android基础同时被 2 个专栏收录

39 篇文章 0 订阅

订阅专栏

技术

9 篇文章 0 订阅

订阅专栏

相信大多数朋友对Service这个名词都不会陌生，没错，一个老练的Android程序员如果连Service都没听说过的话，那确实也太逊了。Service作为Android四大组件之一，在每一个应用程序中都扮演着非常重要的角色。它主要用于在后台处理一些耗时的逻辑，或者去执行某些需要长期运行的任务。必要的时候我们甚至可以在程序退出的情况下，让Service在后台继续保持运行状态。

不过，虽然Service几乎被每一个Android程序员所熟知，但并不是每个人都已经将Service的各个知识点都掌握得非常透彻。那么今天我就将带着大家对Service进行一次全面、深入的探究，希望每个人在读完本篇文章后都能对Service有更深一层的理解。

Service的基本用法

关于Service最基本的用法自然就是如何启动一个Service了，启动Service的方法和启动Activity很类似，都需要借助Intent来实现，下面我们就通过一个具体的例子来看一下。

新建一个Android项目，项目名就叫ServiceTest，这里我选择使用4.0的API。

然后新建一个MyService继承自Service，并重写父类的onCreate()、onStartCommand()和onDestroy()方法，如下所示：

[java] view plain copy

public class MyService extends Service {
public static final String TAG = "MyService";
@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate() executed");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand() executed");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy() executed");
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
}

可以看到，我们只是在onCreate()、onStartCommand()和onDestroy()方法中分别打印了一句话，并没有进行其它任何的操作。

然后打开或新建activity_main.xml作为程序的主布局文件，代码如下所示：

[html] view plain copy

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<Button
android:id="@+id/start_service"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Start Service" />
<Button
android:id="@+id/stop_service"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Stop Service" />
</LinearLayout>

我们在布局文件中加入了两个按钮，一个用于启动Service，一个用于停止Service。

然后打开或新建MainActivity作为程序的主Activity，在里面加入启动Service和停止Service的逻辑，代码如下所示：

[java] view plain copy

public class MainActivity extends Activity implements OnClickListener {
private Button startService;
private Button stopService;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
startService = (Button) findViewById(R.id.start_service);
stopService = (Button) findViewById(R.id.stop_service);
startService.setOnClickListener(this);
stopService.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.start_service:
Intent startIntent = new Intent(this, MyService.class);
startService(startIntent);
break;
case R.id.stop_service:
Intent stopIntent = new Intent(this, MyService.class);
stopService(stopIntent);
break;
default:
break;
}
}
}

可以看到，在Start Service按钮的点击事件里，我们构建出了一个Intent对象，并调用startService()方法来启动MyService。然后在Stop Serivce按钮的点击事件里，我们同样构建出了一个Intent对象，并调用stopService()方法来停止MyService。代码的逻辑非常简单，相信不需要我再多做解释了吧。

另外需要注意，项目中的每一个Service都必须在AndroidManifest.xml中注册才行，所以还需要编辑AndroidManifest.xml文件，代码如下所示：

[html] view plain copy

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.servicetest"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="14"
android:targetSdkVersion="17" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
……
<service android:name="com.example.servicetest.MyService" >
</service>
</application>
</manifest>

这样的话，一个简单的带有Service功能的程序就写好了，现在我们将程序运行起来，并点击一下Start Service按钮，可以看到LogCat的打印日志如下：

也就是说，当启动一个Service的时候，会调用该Service中的onCreate()和onStartCommand()方法。

那么如果我再点击一次Start Service按钮呢？这个时候的打印日志如下：

可以看到，这次只有onStartCommand()方法执行了，onCreate()方法并没有执行，为什么会这样呢？这是由于onCreate()方法只会在Service第一次被创建的时候调用，如果当前Service已经被创建过了，不管怎样调用startService()方法，onCreate()方法都不会再执行。因此你可以再多点击几次Start Service按钮试一次，每次都只会有onStartCommand()方法中的打印日志。

我们还可以到手机的应用程序管理界面来检查一下MyService是不是正在运行，如下图所示：

恩，MyService确实是正在运行的，即使它的内部并没有执行任何的逻辑。

回到ServiceTest程序，然后点击一下Stop Service按钮就可以将MyService停止掉了。

Service和Activity通信

上面我们学习了Service的基本用法，启动Service之后，就可以在onCreate()或onStartCommand()方法里去执行一些具体的逻辑了。不过这样的话Service和Activity的关系并不大，只是Activity通知了Service一下：“你可以启动了。”然后Service就去忙自己的事情了。那么有没有什么办法能让它们俩的关联更多一些呢？比如说在Activity中可以指定让Service去执行什么任务。当然可以，只需要让Activity和Service建立关联就好了。

观察MyService中的代码，你会发现一直有一个onBind()方法我们都没有使用到，这个方法其实就是用于和Activity建立关联的，修改MyService中的代码，如下所示：

[java] view plain copy

public class MyService extends Service {
public static final String TAG = "MyService";
private MyBinder mBinder = new MyBinder();
@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate() executed");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand() executed");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy() executed");
}
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
class MyBinder extends Binder {
public void startDownload() {
Log.d("TAG", "startDownload() executed");
// 执行具体的下载任务
}
}
}

这里我们新增了一个MyBinder类继承自Binder类，然后在MyBinder中添加了一个startDownload()方法用于在后台执行下载任务，当然这里并不是真正地去下载某个东西，只是做个测试，所以startDownload()方法只是打印了一行日志。

然后修改activity_main.xml中的代码，在布局文件中添加用于绑定Service和取消绑定Service的按钮：

[html] view plain copy

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<Button
android:id="@+id/start_service"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Start Service" />
<Button
android:id="@+id/stop_service"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Stop Service" />
<Button
android:id="@+id/bind_service"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Bind Service" />
<Button
android:id="@+id/unbind_service"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Unbind Service"
/>
</LinearLayout>

接下来再修改MainActivity中的代码，让MainActivity和MyService之间建立关联，代码如下所示：

[java] view plain copy

public class MainActivity extends Activity implements OnClickListener {
private Button startService;
private Button stopService;
private Button bindService;
private Button unbindService;
private MyService.MyBinder myBinder;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
myBinder = (MyService.MyBinder) service;
myBinder.startDownload();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
startService = (Button) findViewById(R.id.start_service);
stopService = (Button) findViewById(R.id.stop_service);
bindService = (Button) findViewById(R.id.bind_service);
unbindService = (Button) findViewById(R.id.unbind_service);
startService.setOnClickListener(this);
stopService.setOnClickListener(this);
bindService.setOnClickListener(this);
unbindService.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.start_service:
Intent startIntent = new Intent(this, MyService.class);
startService(startIntent);
break;
case R.id.stop_service:
Intent stopIntent = new Intent(this, MyService.class);
stopService(stopIntent);
break;
case R.id.bind_service:
Intent bindIntent = new Intent(this, MyService.class);
bindService(bindIntent, connection, BIND_AUTO_CREATE);
break;
case R.id.unbind_service:
unbindService(connection);
break;
default:
break;
}
}
}

可以看到，这里我们首先创建了一个ServiceConnection的匿名类，在里面重写了onServiceConnected()方法和onServiceDisconnected()方法，这两个方法分别会在Activity与Service建立关联和解除关联的时候调用。在onServiceConnected()方法中，我们又通过向下转型得到了MyBinder的实例，有了这个实例，Activity和Service之间的关系就变得非常紧密了。现在我们可以在Activity中根据具体的场景来调用MyBinder中的任何public方法，即实现了Activity指挥Service干什么Service就去干什么的功能。

当然，现在Activity和Service其实还没关联起来了呢，这个功能是在Bind Service按钮的点击事件里完成的。可以看到，这里我们仍然是构建出了一个Intent对象，然后调用bindService()方法将Activity和Service进行绑定。bindService()方法接收三个参数，第一个参数就是刚刚构建出的Intent对象，第二个参数是前面创建出的ServiceConnection的实例，第三个参数是一个标志位，这里传入BIND_AUTO_CREATE表示在Activity和Service建立关联后自动创建Service，这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。

然后如何我们想解除Activity和Service之间的关联怎么办呢？调用一下unbindService()方法就可以了，这也是Unbind Service按钮的点击事件里实现的逻辑。

现在让我们重新运行一下程序吧，在MainActivity中点击一下Bind Service按钮，LogCat里的打印日志如下图所示：

另外需要注意，任何一个Service在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity建立关联，还可以和任何一个Activity建立关联，而且在建立关联时它们都可以获取到相同的MyBinder实例。

如何销毁Service

在Service的基本用法这一部分，我们介绍了销毁Service最简单的一种情况，点击Start Service按钮启动Service，再点击Stop Service按钮停止Service，这样MyService就被销毁了，可以看到打印日志如下所示：

那么如果我们是点击的Bind Service按钮呢？由于在绑定Service的时候指定的标志位是BIND_AUTO_CREATE，说明点击Bind Service按钮的时候Service也会被创建，这时应该怎么销毁Service呢？其实也很简单，点击一下Unbind Service按钮，将Activity和Service的关联解除就可以了。

先点击一下Bind Service按钮，再点击一下Unbind Service按钮，打印日志如下所示：

以上这两种销毁的方式都很好理解。那么如果我们既点击了Start Service按钮，又点击了Bind Service按钮会怎么样呢？这个时候你会发现，不管你是单独点击Stop Service按钮还是Unbind Service按钮，Service都不会被销毁，必要将两个按钮都点击一下，Service才会被销毁。也就是说，点击Stop Service按钮只会让Service停止，点击Unbind Service按钮只会让Service和Activity解除关联，一个Service必须要在既没有和任何Activity关联又处理停止状态的时候才会被销毁。

为了证实一下，我们在Stop Service和Unbind Service按钮的点击事件里面加入一行打印日志：

[java] view plain copy

public void onClick(View v) {
switch (v.getId()) {
case R.id.start_service:
Intent startIntent = new Intent(this, MyService.class);
startService(startIntent);
break;
case R.id.stop_service:
Log.d("MyService", "click Stop Service button");
Intent stopIntent = new Intent(this, MyService.class);
stopService(stopIntent);
break;
case R.id.bind_service:
Intent bindIntent = new Intent(this, MyService.class);
bindService(bindIntent, connection, BIND_AUTO_CREATE);
break;
case R.id.unbind_service:
Log.d("MyService", "click Unbind Service button");
unbindService(connection);
break;
default:
break;
}
}

然后重新运行程序，先点击一下Start Service按钮，再点击一下Bind Service按钮，这样就将Service启动起来，并和Activity建立了关联。然后点击Stop Service按钮后Service并不会销毁，再点击一下Unbind Service按钮，Service就会销毁了，打印日志如下所示：

我们应该始终记得在Service的onDestroy()方法里去清理掉那些不再使用的资源，防止在Service被销毁后还会有一些不再使用的对象仍占用着内存。

Service和Thread的关系

不少Android初学者都可能会有这样的疑惑，Service和Thread到底有什么关系呢？什么时候应该用Service，什么时候又应该用Thread？答案可能会有点让你吃惊，因为Service和Thread之间没有任何关系！

之所以有不少人会把它们联系起来，主要就是因为Service的后台概念。Thread我们大家都知道，是用于开启一个子线程，在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候，总会觉得它是用来处理一些后台任务的，一些比较耗时的操作也可以放在这里运行，这就会让人产生混淆了。但是，如果我告诉你Service其实是运行在主线程里的，你还会觉得它和Thread有什么关系吗？让我们看一下这个残酷的事实吧。

在MainActivity的onCreate()方法里加入一行打印当前线程id的语句：

[java] view plain copy

Log.d("MyService", "MainActivity thread id is " + Thread.currentThread().getId());

然后在MyService的onCreate()方法里也加入一行打印当前线程id的语句：

[java] view plain copy

Log.d("MyService", "MyService thread id is " + Thread.currentThread().getId());

现在重新运行一下程序，并点击Start Service按钮，会看到如下打印日志：

可以看到，它们的线程id完全是一样的，由此证实了Service确实是运行在主线程里的，也就是说如果你在Service里编写了非常耗时的代码，程序必定会出现ANR的。

你可能会惊呼，这不是坑爹么！？那我要Service又有何用呢？其实大家不要把后台和子线程联系在一起就行了，这是两个完全不同的概念。Android的后台就是指，它的运行是完全不依赖UI的。即使Activity被销毁，或者程序被关闭，只要进程还在，Service就可以继续运行。比如说一些应用程序，始终需要与服务器之间始终保持着心跳连接，就可以使用Service来实现。你可能又会问，前面不是刚刚验证过Service是运行在主线程里的么？在这里一直执行着心跳连接，难道就不会阻塞主线程的运行吗？当然会，但是我们可以在Service中再创建一个子线程，然后在这里去处理耗时逻辑就没问题了。

额，既然在Service里也要创建一个子线程，那为什么不直接在Activity里创建呢？这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。而且在一个Activity中创建的子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中Binder的实例。因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。

一个比较标准的Service就可以写成：

[java] view plain copy

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
new Thread(new Runnable() {
@Override
public void run() {
// 开始执行后台任务
}
}).start();
return super.onStartCommand(intent, flags, startId);
}
class MyBinder extends Binder {
public void startDownload() {
new Thread(new Runnable() {
@Override
public void run() {
// 执行具体的下载任务
}
}).start();
}
}

创建前台Service

Service几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。但是Service的系统优先级还是比较低的，当系统出现内存不足情况时，就有可能会回收掉正在后台运行的Service。如果你希望Service可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台Service。前台Service和普通Service最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止Service被回收才使用前台Service，有些项目由于特殊的需求会要求必须使用前台Service，比如说墨迹天气，它的Service在后台更新天气数据的同时，还会在系统状态栏一直显示当前天气的信息，如下图所示：

那么我们就来看一下如何才能创建一个前台Service吧，其实并不复杂，修改MyService中的代码，如下所示：

[java] view plain copy

public class MyService extends Service {
public static final String TAG = "MyService";
private MyBinder mBinder = new MyBinder();
@Override
public void onCreate() {
super.onCreate();
Notification notification = new Notification(R.drawable.ic_launcher,
"有通知到来", System.currentTimeMillis());
Intent notificationIntent = new Intent(this, MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
notificationIntent, 0);
notification.setLatestEventInfo(this, "这是通知的标题", "这是通知的内容",
pendingIntent);
startForeground(1, notification);
Log.d(TAG, "onCreate() executed");
}
.........
}

这里只是修改了MyService中onCreate()方法的代码。可以看到，我们首先创建了一个Notification对象，然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据，并在这里设置了点击通知后就打开MainActivity。然后调用startForeground()方法就可以让MyService变成一个前台Service，并会将通知的图片显示出来。

现在重新运行一下程序，并点击Start Service或Bind Service按钮，MyService就会以前台Service的模式启动了，并且在系统状态栏会弹出一个通栏图标，下拉状态栏后可以看到通知的详细内容。

上面都是浮云

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中代码的方法：

<code class="hljs java has-numbering"><span class="hljs-keyword">private</span> <span class="hljs-keyword">void</span> <span class="hljs-title">initStartedService</span>() {
        <span class="hljs-keyword">final</span> Intent intent = <span class="hljs-keyword">new</span> Intent(ServiceDemoActivity.<span class="hljs-keyword">this</span>, HelloStartedService.class);
        startedService.setOnClickListener(<span class="hljs-keyword">new</span> View.OnClickListener() {
            <span class="hljs-annotation">@Override</span>
            <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onClick</span>(View v) {
                Log.e(startedServiceTAG, <span class="hljs-string">"开启服务"</span>);
                intent.putExtra(<span class="hljs-string">"StartedServiceTest"</span>, <span class="hljs-string">"StartedServiceTest"</span>);
                startService(intent);
            }
        });

        stopService.setOnClickListener(<span class="hljs-keyword">new</span> View.OnClickListener() {
            <span class="hljs-annotation">@Override</span>
            <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onClick</span>(View v) {
                Log.e(stopServiceTAG, <span class="hljs-string">"手动停止服务"</span>);
                stopService(intent);
            }
        });
    }</code>

HelloStartedService.Java文件

<code class="hljs java has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">HelloStartedService</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Service</span> {</span>
    <span class="hljs-keyword">private</span> Looper looper;
    <span class="hljs-keyword">private</span> StartedServiceHandler startedServiceHandler;
    <span class="hljs-keyword">public</span> String s;
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">final</span> String TAG = <span class="hljs-string">"startedService"</span>;

    <span class="hljs-keyword">public</span> <span class="hljs-title">HelloStartedService</span>() {
    }

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

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

    }

    <span class="hljs-annotation">@Override</span>
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onDestroy</span>() {
        <span class="hljs-keyword">super</span>.onDestroy();
        Log.e(TAG, <span class="hljs-string">"onDestroy"</span>);
    }

    <span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">StartedServiceHandler</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Handler</span> {</span>
        <span class="hljs-keyword">public</span> <span class="hljs-title">StartedServiceHandler</span>(Looper looper) {
            <span class="hljs-keyword">super</span>(looper);
        }

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


    <span class="hljs-comment">//不支持绑定，所以我们返回null</span>
    <span class="hljs-annotation">@Override</span>
    <span class="hljs-keyword">public</span> IBinder <span class="hljs-title">onBind</span>(Intent intent) {
        <span class="hljs-comment">// TODO: Return the communication channel to the service.</span>
        <span class="hljs-keyword">return</span> <span class="hljs-keyword">null</span>;
    }
}</code>

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

AndroidManifests.xml文件中注册

<code class="hljs xml has-numbering"><span class="hljs-tag"><<span class="hljs-title">service
</span>            <span class="hljs-attribute">android:name</span>=<span class="hljs-value">"com.llay.admin.service.HelloStartedService"</span>
            <span class="hljs-attribute">android:enabled</span>=<span class="hljs-value">"true"</span>
            <span class="hljs-attribute">android:exported</span>=<span class="hljs-value">"true"</span> /></span></code>

运行图：
打开服务：
这里写图片描述
关闭服务（完成后自动关闭）：
在处理过程后，有这样一句代码，自动关闭。

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

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中的方法代码：

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

<ul style="" class="pre-numbering"><li>
</li></ul>

AndroidManifests.xml文件中注册

<code class="hljs xml has-numbering"><span class="hljs-tag"><<span class="hljs-title">service
</span>            <span class="hljs-attribute">android:name</span>=<span class="hljs-value">"com.llay.admin.service.HelloIntentService"</span>
            <span class="hljs-attribute">android:enabled</span>=<span class="hljs-value">"true"</span>
            <span class="hljs-attribute">android:exported</span>=<span class="hljs-value">"true"</span> /></span></code>

运行图：
开启Intent服务：
这里写图片描述
关闭Intent服务（这里和上面started服务一样，可以自动关闭，可以手动关闭）：

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

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

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

4、2 Bound服务的代码实现

Activity中的方法代码：

<code class="hljs java has-numbering"><span class="hljs-keyword">private</span> <span class="hljs-keyword">void</span> <span class="hljs-title">initBoundService</span>() {
        boundService.setOnClickListener(<span class="hljs-keyword">new</span> View.OnClickListener() {
            <span class="hljs-annotation">@Override</span>
            <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onClick</span>(View v) {
                Log.e(boundServiceTAG, <span class="hljs-string">"绑定服务"</span>);
                <span class="hljs-comment">//绑定到LocalService</span>
                Intent intent = <span class="hljs-keyword">new</span> Intent(ServiceDemoActivity.<span class="hljs-keyword">this</span>, HelloBoundService.class);
                bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
                Log.e(<span class="hljs-string">"BoundServiceTest"</span>, <span class="hljs-string">"BoundServiceStart"</span>);
            }
        });

        unboundService.setOnClickListener(<span class="hljs-keyword">new</span> View.OnClickListener() {
            <span class="hljs-annotation">@Override</span>
            <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onClick</span>(View v) {
                Log.e(unBoundServiceTAG, <span class="hljs-string">"手动解除绑定"</span>);
                unbindService(serviceConnection);
                mBound = <span class="hljs-keyword">false</span>;
            }
        });

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

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

            <span class="hljs-annotation">@Override</span>
            <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onServiceDisconnected</span>(ComponentName name) {
                mBound = <span class="hljs-keyword">false</span>;
            }
        };
    }


    <span class="hljs-comment">//以下是绑定服务的一些回调函数</span>
    <span class="hljs-annotation">@Override</span>
    <span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onStart</span>() {
        <span class="hljs-keyword">super</span>.onStart();
    }

    <span class="hljs-annotation">@Override</span>
    <span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onStop</span>() {
        <span class="hljs-keyword">super</span>.onStop();
        <span class="hljs-comment">//与服务解除绑定</span>
        <span class="hljs-keyword">if</span> (mBound) {
            unbindService(serviceConnection);
            mBound = <span class="hljs-keyword">false</span>;
        }
        Log.e(unBoundServiceTAG, <span class="hljs-string">"自动解除绑定"</span>);
    }</code>

HelloBoundService.java文件：

<code class="hljs java has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">HelloBoundService</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Service</span> {</span>
    <span class="hljs-comment">//给客户端的Binder</span>
    <span class="hljs-keyword">public</span> IBinder mBinder = <span class="hljs-keyword">new</span> LocalBinder();
    <span class="hljs-comment">//生成随机数</span>
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">final</span> Random mGenerator = <span class="hljs-keyword">new</span> Random();


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

    <span class="hljs-annotation">@Nullable</span>
    <span class="hljs-annotation">@Override</span>
    <span class="hljs-keyword">public</span> IBinder <span class="hljs-title">onBind</span>(Intent intent) {
        <span class="hljs-keyword">return</span> mBinder;
    }

    <span class="hljs-javadoc">/**
     * method for clients
     */</span>
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">int</span> <span class="hljs-title">getRandomNumber</span>() {
        <span class="hljs-keyword">return</span> mGenerator.nextInt(<span class="hljs-number">100</span>);
    }
}</code>

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

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

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

AndroidManifests.xml文件中注册

<code class="hljs xml has-numbering"><span class="hljs-tag"><<span class="hljs-title">service
</span>            <span class="hljs-attribute">android:name</span>=<span class="hljs-value">"com.llay.admin.service.HelloBoundService"</span>
            <span class="hljs-attribute">android:enabled</span>=<span class="hljs-value">"true"</span>
            <span class="hljs-attribute">android:exported</span>=<span class="hljs-value">"true"</span> /></span></code>

运行图：
绑定服务：
这里写图片描述
解絆服务：

五、扩展

创建一个支持绑定的服务时，你必须提供一个 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
文档。

科克蛙

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Service的理解和使用

相信大多数朋友对Service这个名词都不会陌生，没错，一个老练的Android程序员如果连Service都没听说过的话，那确实也太逊了。Service作为Android四大组件之一，在每一个应用程序中都扮演着非常重要的角色。它主要用于在后台处理一些耗时的逻辑，或者去执行某些需要长期运行的任务。必要的时候我们甚至可以在程序退出的情况下，让Service在后台继续保持运行状态。不过，虽然Se
复制链接

扫一扫

专栏目录