Android服务Service详解.docx

Android服务Service详解.docx

《Android服务Service详解.docx》由会员分享，可在线阅读，更多相关《Android服务Service详解.docx（95页珍藏版）》请在冰豆网上搜索。

Android服务Service详解

第8章Android服务

8.1Service起步

8.1.1Service的生命周期

8.1.2绑定Activity和Service

8.1.3在BroadcastReceiver中启动Ser..

8.2.1获得系统服务

8.2.2在模拟器上模拟重力感应

8.3.1计时器：

Chronometer

8.3.2预约时间Handler

8.3.4在线程中更新GUI组件

8.3.5全局定时器AlarmManager

（1）

8.3.5全局定时器AlarmManager

（2）

8.3.5全局定时器AlarmManager（3）

8.4.1什么是AIDL服务

8.4.2建立AIDL服务的步骤

（1）

8.4.2建立AIDL服务的步骤

（2）

8.4.2建立AIDL服务的步骤（3）

8.5本章小结

第8章Android服务

服务（Service）是Android系统中4个应用程序组件之一（其他的组件详见3.2节的内容）。

服务主要用于两个目的：

后台运行和跨进程访问。

通过启动一个服务，可以在不显示界面的前提下在后台运行指定的任务，这样可以不影响用户做其他事情。

通过AIDL服务可以实现不同进程之间的通信，这也是服务的重要用途之一。

本章内容

Service的生命周期

绑定Activity和Service

在BroadcastReceiver中启动Service

系统服务

时间服务

在线程中更新GUI组件

AIDL服务

在AIDL服务中传递复杂的数据

8.1 Service起步

Service并没有实际界面，而是一直在Android系统的后台运行。

一般使用Service为应用程序提供一些服务，或不需要界面的功能，例如，从Internet下载文件、控制Video播放器等。

本节主要介绍Service的启动和结束过程（Service的生命周期）以及启动Service的各种方法。

8.1.1 Service的生命周期

本节的例子代码所在的工程目录是src\ch08\ch08_servicelifecycle

Service与Activity一样，也有一个从启动到销毁的过程，但Service的这个过程比Activity简单得多。

Service启动到销毁的过程只会经历如下3个阶段：

创建服务

开始服务

销毁服务

一个服务实际上是一个继承android.app.Service的类，当服务经历上面3个阶段后，会分别调用Service类中的3个事件方法进行交互，这3个事件方法如下：

1.public void onCreate（）;                     //  创建服务 

2.public void onStart（Intent intent, int startId）;            //  开始服务 

3.public void onDestroy（）;                        //  销毁服务 

一个服务只会创建一次，销毁一次，但可以开始多次，因此，onCreate和onDestroy方法只会被调用一次，而onStart方法会被调用多次。

下面编写一个服务类，具体看一下服务的生命周期由开始到销毁的过程。

1.package net.blogjava.mobile.service; 

2.import android.app.Service; 

3.import android.content.Intent; 

4.import android.os.IBinder; 

5.import android.util.Log; 

6. 

7.//  MyService是一个服务类，该类必须从android.app.Service类继承 

8.public class MyService extends Service 

9.{ 

10.    @Override 

11.    public IBinder onBind（Intent intent） 

12.    { 

13.        return null; 

14.    } 

15.    //  当服务第1次创建时调用该方法 

16.    @Override 

17.    public void onCreate（） 

18.    { 

19.        Log.d（"MyService", "onCreate"）; 

20.        super.onCreate（）; 

21.    } 

22.    //  当服务销毁时调用该方法 

23.    @Override 

24.    public void onDestroy（） 

25.    { 

26.        Log.d（"MyService", "onDestroy"）; 

27.        super.onDestroy（）; 

28.    } 

29.    //  当开始服务时调用该方法 

30.    @Override 

31.    public void onStart（Intent intent, int startId） 

32.    { 

33.        Log.d（"MyService", "onStart"）; 

34.        super.onStart（intent, startId）; 

35.    } 

36.} 

在MyService中覆盖了Service类中3个生命周期方法，并在这些方法中输出了相应的日志信息，以便更容易地观察事件方法的调用情况。

读者在编写Android的应用组件时要注意，不管是编写什么组件（例如，Activity、Service等），都需要在AndroidManifest.xml文件中进行配置。

MyService类也不例子。

配置这个服务类很简单，只需要在AndroidManifest.xml文件的标签中添加如下代码即可：

1.

enabled="true" android:

name=".MyService" /> 

其中android:

enabled属性的值为true，表示MyService服务处于激活状态。

虽然目前MyService是激活的，但系统仍然不会启动MyService，要想启动这个服务。

必须显式地调用startService方法。

如果想停止服务，需要显式地调用stopService方法，代码如下：

1.public void onClick（View view） 

2.{ 

3.    switch （view.getId（）） 

4.    { 

5.        case R.id.btnStartService:

6.            startService（serviceIntent）;        

//  单击【Start Service】按钮启动服务 

7.            break; 

8.        case R.id.btnStopService:

9.            stopService（serviceIntent）;     

//  单击【Stop Service】按钮停止服务 

10.            break; 

11.    } 

12.} 

其中serviceIntent是一个Intent对象，用于指定MyService服务，创建该对象的代码如下：

1.serviceIntent = new Intent（this, MyService.class）; 

运行本节的例子后，会显示如图8.1所示的界面。

图8.1 开始和停止服务

第1次单击【StartService】按钮后，在DDMS透视图的LogCat视图的Message列会输出如下两行信息：

1.onCreate 

2.onStart 

然后单击【StopService】按钮，会在Message列中输出如下信息：

1.onDestroy 

下面按如下的单击按钮顺序的重新测试一下本例。

【StartService】→【StopService】→【StartService】→【StartService】→【StartService】→【StopService】

测试完程序，就会看到如图8.2所示的输出信息。

可以看出，只在第1次单击【StartService】按钮后会调用onCreate方法，如果在未单击【StopService】按钮时多次单击【StartService】按钮，系统只在第1次单击【StartService】按钮时调用onCreate和onStart方法，再单击该按钮时，系统只会调用onStart方法，而不会再次调用onCreate方法。

图8.2 服务的生命周期方法的调用情况

在讨论完服务的生命周期后，再来总结一下创建和开始服务的步骤。

创建和开始一个服务需要如下3步：

（1）编写一个服务类，该类必须从android.app.Service继承。

Service类涉及到3个生命周期方法，但这3个方法并不一定在子类中覆盖，读者可根据不同需求来决定使用哪些生命周期方法。

在Service类中有一个onBind方法，该方法是一个抽象方法，在Service的子类中必须覆盖。

这个方法当Activity与Service绑定时被调用（将在8.1.3节详细介绍）。

（2）在AndroidManifest.xml文件中使用标签来配置服务，一般需要将标签的android:

enabled属性值设为true，并使用android:

name属性指定在第1步建立的服务类名。

（3）如果要开始一个服务，使用startService方法，停止一个服务要使用stopService方法。

8.1.2 绑定Activity和Service

本节的例子代码所在的工程目录是src\ch08\ch08_serviceactivity

如果使用8.1.1节介绍的方法启动服务，并且未调用stopService来停止服务，这个服务就会随着Android系统的启动而启动，随着Android系统的关闭而关闭。

也就是服务会在Android系统启动后一直在后台运行，直到Android系统关闭后服务才停止。

但有时我们希望在启动服务的Activity关闭后服务自动关闭，这就需要将Activity和Service绑定。

通过bindService方法可以将Activity和Service绑定。

bindService方法的定义如下：

1.public boolean bindService（Intent service, 

ServiceConnection conn, int flags）  

该方法的第1个参数表示与服务类相关联的Intent对象，第2个参数conn是一个ServiceConnection类型的变量，负责连接Intent对象指定的服务。

通过ServiceConnection对象可以获得连接成功或失败的状态，并可以获得连接后的服务对象。

第3个参数是一个标志位，一般设为Context.BIND_AUTO_CREATE。

下面重新编写8.1.1节的MyService类，在该类中增加了几个与绑定相关的事件方法。

1.package net.blogjava.mobile.service; 

2. 

3.import android.app.Service; 

4.import android.content.Intent; 

5.import android.os.Binder; 

6.import android.os.IBinder; 

7.import android.util.Log; 

8. 

9.public class MyService extends Service 

10.{ 

11.    private MyBinder myBinder = new MyBinder（）; 

12.    //  成功绑定后调用该方法 

13.    @Override 

14.    public IBinder onBind（Intent intent） 

15.    { 

16.        Log.d（"MyService", "onBind"）; 

17.        return myBinder; 

18.    } 

19.    //  重新绑定时调用该方法 

20.    @Override 

21.    public void onRebind（Intent intent） 

22.    { 

23.        Log.d（"MyService", "onRebind"）; 

24.        super.onRebind（intent）; 

25.    } 

26.    //  解除绑定时调用该方法 

27.    @Override 

28.    public boolean onUnbind（Intent intent） 

29.    { 

30.        Log.d（"MyService", "onUnbind"）; 

31.        return super.onUnbind（intent）; 

32.    } 

33.    @Override 

34.    public void onCreate（） 

35.    { 

36.        Log.d（"MyService", "onCreate"）; 

37.        super.onCreate（）; 

38.    } 

39.    @Override 

40.    public void onDestroy（） 

41.    { 

42.        Log.d（"MyService", "onDestroy"）; 

43.        super.onDestroy（）; 

44.    } 

45.    @Override 

46.    public void onStart（Intent intent, int startId） 

47.    { 

48.        Log.d（"MyService", "onStart"）; 

49.        super.onStart（intent, startId）; 

50.    } 

51.    public class MyBinder extends Binder 

52.    { 

53.        MyService getService（） 

54.        { 

55.            return MyService.this; 

56.        } 

57.    } 

58.} 

现在定义一个MyService变量和一个ServiceConnection变量，代码如下：

1.private MyService myService; 

2.private ServiceConnection serviceConnection = new ServiceConnection（） 

3.{ 

4.    //  连接服务失败后，该方法被调用 

5.    @Override 

6.    public void onServiceDisconnected（ComponentName name） 

7.    { 

8.        myService = null; 

9.        Toast.makeText（Main.this, "Service 

Failed.", Toast.LENGTH_LONG）.show（）; 

10.    } 

11.    //  成功连接服务后，该方法被调用。

在该方法中可以获得MyService对象 

12.    @Override 

13.    public void onServiceConnected（ComponentName name, IBinder service） 

14.    { 

15.        //  获得MyService对象 

16.        myService = （（MyService.MyBinder） service）.getService（）; 

17.        Toast.makeText（Main.this, "Service 

Connected.", Toast.LENGTH_LONG）.show（）; 

18.    } 

19.}; 

最后使用bindService方法来绑定Activity和Service，代码如下：

1.bindService（serviceIntent, serviceConnection, Context.BIND_AUTO_CREATE）; 

如果想解除绑定，可以使用下面的代码：

1.unbindService（serviceConnection）; 

在MyService类中定义了一个MyBinder类，该类实际上是为了获得MyService的对象实例的。

在ServiceConnection接口的onServiceConnected方法中的第2个参数是一个IBinder类型的变量，将该参数转换成MyService.MyBinder对象，并使用MyBinder类中的getService方法获得MyService对象。

在获得MyService对象后，就可以在Activity中随意操作MyService了。

运行本节的例子后，单击【BindService】按钮，如果绑定成功，会显示如图8.3所示的信息提示框。

关闭应用程序后，会看到在LogCat视图中输出了onUnbind和onDestroy信息，表明在关闭Activity后，服务先被解除绑定，最后被销毁。

如果先启动（调用startService方法）一个服务，然后再绑定（调用bindService方法）服务，会怎么样呢？

在这种情况下，虽然服务仍然会成功绑定到Activity上，但在Activity关闭后，服务虽然会被解除绑定，但并不会被销毁，也就是说，MyService类的onDestroy方法不会被调用。

图8.3 绑定服务

8.1.3 在BroadcastReceiver中启动Service

本节的例子代码所在的工程目录是src\ch08\ch08_startupservice

在8.1.1节和8.1.2节都是先启动了一个Activity，然后在Activity中启动服务。

如果是这样，在启动服务时必须要先启动一个Activity。

在很多时候这样做有些多余，阅读完第7章的内容，会发现实例43可以利用BroadcastReceiver在Android系统启动时运行一个Activity。

也许我们会从中得到一些启发，既然可以在BroadcastReceiver中启动Activity，为什么不能启动Service呢？

说做就做，现在让我们来验证一下这个想法。

先编写一个服务类，这个服务类没什么特别的，仍然使用前面两节编写的MyService类即可。

在AndroidManifest.xml文件中配置MyService类的代码也相同。

下面来完成最关键的一步，就是建立一个BroadcastReceiver，代码如下：

1.package net.blogjava.mobile.startupservice; 

2. 

3.import android.content.BroadcastReceiver; 

4.import android.content.Context; 

5.import android.content.Intent; 

6. 

7.public class StartupReceiver extends BroadcastReceiver 

8.{ 

9.    @Override 

10.    public void onReceive（Context context, Intent intent） 

11.    { 

12.        //  启动一个Service 

13.        Intent serviceIntent = new Intent（context, MyService.class）;         

14.        context.startService（serviceIntent）;         

15.        Intent activityIntent = new Intent（context, MessageActivity.class）; 

16.        //  要想在Service中启动Activity，必须设置如下标志 

17.        activityIntent.setFlags（Intent.FLAG_ACTIVITY_NEW_TASK）; 

18.        context.startActivity（activityIntent）; 

19.    } 

20.} 

在StartupReceiver类的onReceive方法中完成了两项工作：

启动服务和显示一个Activity来提示服务启动成功。

其中MessageActivity是一个普通的Activity类，只是该类在配置时使用了"@android:

style/Theme.Dialog"主题，因此，如果服务启动成功，会显示如图8.4所示的信息。

图8.4 在BroadcastReceiver中启动服务

如果安装本例后，在重新启动模拟器后并未出现如图8.4所示的信息提示框，最大的可能是没有在AndroidManifest.xml文件中配置BroadcastReceiver和Service，下面来看一下AndroidManifest.xml文件的完整代码。

1.

xml version="1.0" encoding="utf-8"?

> 

2.

android=" 

3.    package="net.blogjava.mobile.startupservice"

 android:

versionCode="1" 

4.    android:

versionName="1.0"> 

5.    

icon="@drawable/icon" 

android:

label="@string/app_name"> 

6.