Android学习笔记39:Android四大组件之Service

  Android应用程序的四大组件分别是Activity、Service、BroadcastReceiver和ContentProvider。其中,有关Activity的介绍可以参阅博文《Android学习笔记38:Android四大组件之Activity》。有关ContentProvider的使用方法可以参阅博文《Android学习笔记37:使用Content Providers方式共享数据

  本文将主要对Service进行介绍。

 

1.Service简介

  与Activity不同,Service没有提供与用户进行交互的用户界面。Service是运行在后台的一种Android组件,当应用程序需要进行某种不需要前台显示的计算或数据处理时,就可以启动一个Service来实现。

  使用Service的目的通常有两个:后台运行和跨进程访问。通过启动一个Service,可以在不显示界面的前提下在后台运行指定的任务,这样可以不影响用户进行界面操作。通过AIDL(Android Interface Definition Language)服务实现不同进程之间的通信。

1.1Service的生命周期

  Service一般由Activity或其他的Context对象来启动,启动方式有两种,对应的生命周期也不相同,具体如图1所示。

Android学习笔记39:Android四大组件之Service_第1张图片

图1 Service生命周期示意图

  由图1可以看出,通过startService()方法和通过bindService()方法启动Service是不一样的,下面就具体说说这两种方式的区别。

1.2通过startService()方法启动Service

  一个Service从启动到销毁会经历3个阶段,分别是启动服务、服务执行和销毁服务。当Service经历上述3个阶段时,会分别调用Service类中的3个相应的事件方法:

  (1)public void onCreate();

  (2)public int onStartCommand(Intent intent, int flags, int startId);

  (3)public void onDestroy();

  其中,onCreate()方法用于创建Service;onStartCommand()方法用于开始Service;onDestroy()方法用于销毁服务。

  需要注意的一点是,一个Service只会被创建一次,销毁一次,但可以开始多次,也就是说,onCreate()方法和onDestroy()只会被调用一次,而onStartCommand()方法却可以被多次调用。

  下面就来简单的验证一下。

  首先,我们需要自定义一个Service,让其继承android.app.Service类,并实现其中的onCreate()、onStartCommand()和onDestroy()方法。这里,我创建了一个名为“MyService”的Service类,具体代码如下:

 1   /*
 2      * 自定义的Service类
 3      * 博客园-依旧淡然
 4      */
 5   public class MyService extends Service {
 6   
 7       private static final String TAG = "MyService";
 8       
 9       @Override
10       public void onCreate() {
11           super.onCreate();
12           Log.i(TAG, "MyService-->onCreate()");
13       }
14 
15       @Override
16       public int onStartCommand(Intent intent, int flags, int startId) {
17           Log.i(TAG, "MyService-->onStartCommand()");
18           return super.onStartCommand(intent, flags, startId);
19       }
20   
21       @Override
22       public IBinder onBind(Intent intent) {
23           return null;
24       }
25       
26       @Override
27       public void onDestroy() {
28           super.onDestroy();
29           Log.i(TAG, "MyService-->onDestroy()");
30       }
31   }

  其中,onBind()方法是android.app.Service类的抽象方法,所以必须在子类MyService中实现。使用bindService()方法启动Service时,需要用到该方法,这里暂时未用到,所以直接返回null即可。

  实现了自定义的MyService之后,我们便可以在Context对象(比如Activity)中通过调用startService(Intent intent)方法来启动Service,或是通过调用stopService(Intent intent)方法来终止Service。其中,startService()方法和stopService()方法中的参数intent可以用来指定想要启动和终止Service是哪一个。如下的代码,实现了通过Button按钮button_startService启动MyService,通过Button按钮button_stopService停止Service。

 1     /*
 2      * 实现事件监听器接口
 3      * 博客园-依旧淡然
 4      */
 5     private OnClickListener clickListenter = new OnClickListener() {
 6         public void onClick(View view) {
 7             switch(view.getId()) {
 8             case R.id.button_startService:                    //启动Service
 9                 Intent intent_startService = new Intent(MainActivity.this, MyService.class);
10                 startService(intent_startService);
11                 break;
12             case R.id.button_stopService:                    //停止Service
13                 Intent intent_stopService = new Intent(MainActivity.this, MyService.class);
14                 stopService(intent_stopService);
15                 break;
16             }
17         }
18     };

  最后,我们还需要在AndroidManifest.xml文件中注册我们自定义的MyService组件,即在<application></application>标签中添加如下代码即可:

1   <!-- 注册MyService组件 -->
2     <service 
3         android:name=".MyService"    >
4     </service>

  至此,我们便完成了MyService的创建。

  运行程序,点击Button按钮button_startService启动MyService,可以看到“MyService-->onCreate()”以及“MyService-->onStartCommand()”的Log输出信息,表明MyService已经启动。同时,我们也可以点击Menu,退出MainActivity,并依次选择Settings/Applications/Running Services,可以看到如图2所示的界面。

Android学习笔记39:Android四大组件之Service_第2张图片

图2 MyService运行在后台

  由图2可以看出,即使退出了MainActivity(MyService的启动者),MyService也不会停止,它仍然会在后台运行。

  当我们再次运行程序,并再次点击Button按钮button_startService启动MyService时,可以看到“MyService-->onStartCommand()”的Log输出信息,表明当Service已经启动时,如果再次调用startService()方法,将只会调用Service类的onStartCommand()方法。

  最后,当我们Button按钮button_stopService时,可以看到“MyService-->onDestroy()”的Log输出信息,表明MyService调用了onDestroy()方法停止了Service。

1.3通过bindService()方法启动Service

  可以看到,通过startService()方式启动Service时,即使启动该Service的Context对象(比如Activity)关闭了,Service仍然会一直运行在后台(如果没有调用stopService()方法的话)。有时我们希望当启动Service的Context对象关闭时,Service也随之关闭,这时我们就可以通过使用bindService()方法来启动Service。通过bindService()方法启动Service可以将Activity和Service绑定。

  下面同样以一个简单的实例来说明如何创建一个Service,并通过bindService()方法来启动该Service。

  首先,我们需要自定义一个Service,让其继承android.app.Service类,并实现其中的onBind()、onRebind()和onUnbind()方法。这里,我创建了一个名为“BinderService”的Service类,具体代码如下:

 1   /*
 2    * 自定义的Service类
 3    * 博客园-依旧淡然
 4    */
 5   public class BinderService extends Service {
 6   
 7       private MyBinder myBinder = new MyBinder();        //MyBinder对象,用于获得BinderService对象
 8       private static final String TAG = "BinderService";
 9       
10       //成功绑定时调用该方法
11       public IBinder onBind(Intent intent) {
12           Log.i(TAG, "-->onBind()");
13           return myBinder;
14       }
15       
16       //重新绑定时调用该方法
17       public void onRebind(Intent intent) {
18           super.onRebind(intent);
19           Log.i(TAG, "-->onRebind()");
20       }
21   
22       //解除绑定时调用该方法
23       public boolean onUnbind(Intent intent) {
24           Log.i(TAG, "-->onUnbind()");
25           return super.onUnbind(intent);
26       }
27   
28       /*
29        * MyBinder内部类,扩展自Binder类
30        */
31       public class MyBinder extends Binder {
32           
33           //获取BinderService对象
34           public BinderService getBinderService() {
35               return BinderService.this;
36           }
37           
38       }
39   
40   }

  其中,当BinderService成功绑定时会调用onBind()方法;当BinderService重新绑定时会调用onRebind()方法;当BinderService解除绑定时会调用onUnbind()方法。MyBinder内部类继承自Binder类,并实现了getBinderService()方法,用于获取当前BinderService对象。

  实现了自定义的BinderService之后,我们便可以在Context对象(比如Activity)中通过调用bindService(Intent service, ServiceConnection conn, int flags)方法启动Service,或是通过调用unbindService(ServiceConnection conn)方法来终止Service。

  在bindService()方法中,第一个参数service表示与Service类相关联的Intent对象;第二个参数conn是一个ServiceConnection接口对象,负责连接Intent对象指定的Service,通过ServiceConnection对象可以获得连接Service成功或者失败的状态;第三个参数flags,一般设置为Context.BIND_AUTO_CREATE。

  创建ServiceConnection接口对象时,需要实现ServiceConnection接口中的抽象方法onServiceConnected()和onServiceDisconnected()。其中,onServiceConnected()方法在连接Service成功时会被调用,onServiceDisconnected()方法在连接Service失败时会被调用。如下的代码实现了这两个方法。

 1     /*
 2      * 实现ServiceConnection接口
 3      * 博客园-依旧淡然
 4      */
 5     private ServiceConnection serviceConnection = new ServiceConnection() {
 6 
 7         //连接Service
 8         public void onServiceConnected(ComponentName name, IBinder iBinder) {
 9             isBinderServiceConnected = true;
10             MyBinder myBinder = (MyBinder)iBinder;
11             BinderService binderService = myBinder.getBinderService();//获得BinderService对象
12             //binderService.xxx();        //调用BinderService中的自定义方法,进行Service相关操作
13         }
14 
15         //断开Service
16         public void onServiceDisconnected(ComponentName name) {
17             isBinderServiceConnected = false;
18         }
19         
20     };

  通过以上的代码可以看到,我们之前在BinderService类中定义的内部类MyBinder的作用就是获取BinderService对象的实例。获得了BinderService对象之后,便可以在Context对象中调用BinderService中的自定义方法,进行Service相关操作了。

  需要注意的一点是,在Context对象中通过调用bindService()方法启动Service时,onCreate()方法和onRebind()方法会被调用,在Context对象中通过调用unbindService()方法来终止Service时,onUnbind()方法和onDestroy()方法会被调用。

 

2.IntentService的使用

  上面分别介绍了如何通过startService()方式和bindService()方法来启动一个自定义的Service,在使用这两个方法时需要注意以下两个问题。

2.1 UI界面卡死

  因为Service和启动它的Context对象(比如Activity)是在同一个线程里面,所以当我们直接在onStartCommand()方法中进行Service操作时,将会导致UI界面卡死。

  我们可以通过Thread.currentThread().getId()方法来获得主线程以及Service线程的线程Id号,输出Log信息如图3所示。


图3 Log输出信息(1)

  由图3可以看出,Service和启动它的Activity确实是在同一个线程里。这样所带来的直接后果就是,当Service进行比较耗时的操作时UI界面卡死。比如,点击Button启动一个Service进行文件下载,那么在文件下载期间,UI界面将无法和用户进行交互。

2.2多进程调用

  为了解决上面出现的问题,一种简单的解决方法就是在Service的onStartCommand()方法中重新启动一个线程,然后在新启动的线程中进行文件下载等耗时的操作。如下面的代码所示:

 1     @Override
 2     public int onStartCommand(Intent intent, int flags, int startId) {
 3         new MyThread().start();            //启动一个新的线程
 4         return super.onStartCommand(intent, flags, startId);
 5     }
 6 
 7     /*
 8      * 内部类,用于启动一个新的线程
 9      * 博客园-依旧淡然
10      */    
11   private class MyThread extends Thread {
12 
13         @Override
14         public void run() {
15             try {
16                 Thread.sleep(2000);            //模拟文件下载等耗时的操作
17                 Log.i(TAG, "MyService线程ID-->" + Thread.currentThread().getId());
18             } catch (InterruptedException e) {
19                 e.printStackTrace();
20             }
21         }
22         
23     }

  很显然,使用如上的方式,会比直接将文件下载等耗时的操作放在onStartCommand()方法中进行处理要好的多。

  但是,当我们多次启动Service时,onStartCommand()方法将多次被调用,从而导致启动多个线程,如图4所示。

Android学习笔记39:Android四大组件之Service_第3张图片

图4 Log输出信息(2)

  由图4可以看出,使用改进后的方法,UI界面能够实时响应用户请求了,但是与此同时也引入了多线程调用的问题。

2.3 IntentService的使用

  为了避免多线程调用的问题,Android提供了IntentService。

  IntentService是Service的一个子类,主要用于处理异步请求。客户端通过startService(Intent intent)方法传递Intent请求给IntentService。在IntentService中,创建了一个与应用程序主线程分开的worker thread,用来处理所有传过来的Intent请求,当处理完所有的intent后停止Service。

  实现IntentService的方法也很简单,覆写IntentService类的构造方法以及onHandleIntent()方法即可,在onHandleIntent()方法中可以完成比较耗时的操作。

  如下的代码自定义了一个名为“MyIntentService”的类,该类继承自IntentService,并覆写IntentService类的构造方法以及onHandleIntent()方法。

 1   /*
 2    * MyIntentService类,继承自IntentService
 3    * 博客园-依旧淡然
 4    */
 5   public class MyIntentService extends IntentService {
 6       
 7       private static final String TAG = "MyIntentService";
 8       
 9       //构造方法
10       public MyIntentService(String name) {
11           super("MyIntentService");
12       }
13   
14       @Override
15       protected void onHandleIntent(Intent intent) {
16           try {
17               Thread.sleep(2000);                //模拟文件下载等耗时的操作
18               Log.i(TAG, "MyIntentService线程ID-->" + Thread.currentThread().getId());
19           } catch (InterruptedException e) {
20               e.printStackTrace();
21           }            
22       }
23   
24   }

  当我们多次启动MyIntentService时,可以看到如图5所示的Log输出信息。

Android学习笔记39:Android四大组件之Service_第4张图片

图5 Log输出信息(3)

  由图5可以看出,使用IntentService确实可以避免多线程调用。这是因为,在IntentService中默认创建了一个work queue,当IntentService收到多个Intent请求时,IntentService会将这些Intent请求依次放入work queue中,然后一次只传递一个Intent请求到onHandleIntent()方法中进行处理,从而避免了多线程调用。

  需要注意的一点是,在IntentService中默认实现了onBind()方法,其返回值为null。同样,在IntentService中也默认实现了onStartCommand()方法,在这个方法中实现了将Intent请求放到work queue中。

你可能感兴趣的:(Android学习)