[关闭]
@linux1s1s 2017-01-22T09:36:22.000000Z 字数 8033 阅读 1361

Android Service 浅析

AndroidComponent 2015-12


为什么用Service

回顾Activity

说起Service之前先来看看四个卵胞兄弟,因为ContentProviderBroadcastReceiverService没有太大关联,所以重点看一下卵胞兄弟Activity即可,老规矩,还是read the fucking source code开始,代码从startActivity开始。

  1. public class MainActivity extends ActionBarActivity
  2. {
  3. @Override
  4. protected void onCreate(Bundle savedInstanceState)
  5. {
  6. super.onCreate(savedInstanceState);
  7. setContentView(R.layout.activity_main);
  8. ...
  9. startActivity(new Intent(this, TabActivity.class));
  10. }
  11. }

上面这处代码再熟悉不过了,我们跟下去看看究竟。

  1. @Override
  2. public void startActivity(Intent intent) {
  3. this.startActivity(intent, null);
  4. }

继续跟下去会进入到接口IActivityManager

  1. public interface IActivityManager extends IInterface {
  2. public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
  3. String resolvedType, IBinder resultTo, String resultWho, int requestCode, int flags,
  4. ProfilerInfo profilerInfo, Bundle options) throws RemoteException;
  5. }

进入到实现类ActivityManagerNative

  1. public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
  2. String resolvedType, IBinder resultTo, String resultWho, int requestCode,
  3. int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
  4. Parcel data = Parcel.obtain();
  5. Parcel reply = Parcel.obtain();
  6. data.writeInterfaceToken(IActivityManager.descriptor);
  7. data.writeStrongBinder(caller != null ? caller.asBinder() : null);
  8. data.writeString(callingPackage);
  9. intent.writeToParcel(data, 0);
  10. data.writeString(resolvedType);
  11. data.writeStrongBinder(resultTo);
  12. data.writeString(resultWho);
  13. data.writeInt(requestCode);
  14. data.writeInt(startFlags);
  15. if (profilerInfo != null) {
  16. data.writeInt(1);
  17. profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  18. } else {
  19. data.writeInt(0);
  20. }
  21. if (options != null) {
  22. data.writeInt(1);
  23. options.writeToParcel(data, 0);
  24. } else {
  25. data.writeInt(0);
  26. }
  27. mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
  28. reply.readException();
  29. int result = reply.readInt();
  30. reply.recycle();
  31. data.recycle();
  32. return result;
  33. }

这个方法简单分析一下,L27之前都是数据在跨进程之前需要进行打包处理,然后L27调用transact方法,进入NDK方法,最后从replay中取得返回结果。

重回Service

上面跟了这么多代码,最重要的一点就是Activity组件的跳转是完全解耦的,说的更直接一点是只需要Context上下文即可完成跳转,意即无论再任何场景下,只要有Context上下文,想怎么跳转就怎么跳转,这么好的特性,是不是在剩下的四个卵胞兄弟中也有这样的特性?带着这个疑问我们继续跟一下startService

  1. public class MainActivity extends ActionBarActivity
  2. {
  3. @Override
  4. protected void onCreate(Bundle savedInstanceState)
  5. {
  6. super.onCreate(savedInstanceState);
  7. setContentView(R.layout.activity_main);
  8. ...
  9. startService(new Intent(this, TabService.class));
  10. }
  11. }

跟下去,进入ContextWrapper

  1. @Override
  2. public ComponentName startService(Intent service) {
  3. return mBase.startService(service);
  4. }

进入实现类ContextImpl

  1. @Override
  2. public ComponentName startService(Intent service) {
  3. warnIfCallingFromSystemProcess();
  4. return startServiceCommon(service, mUser);
  5. }

第一行就是个warning,第二行继续跟下去进入ActivityManagerProxy代理类

  1. public ComponentName startService(IApplicationThread caller, Intent service,
  2. String resolvedType, int userId) throws RemoteException
  3. {
  4. Parcel data = Parcel.obtain();
  5. Parcel reply = Parcel.obtain();
  6. data.writeInterfaceToken(IActivityManager.descriptor);
  7. data.writeStrongBinder(caller != null ? caller.asBinder() : null);
  8. service.writeToParcel(data, 0);
  9. data.writeString(resolvedType);
  10. data.writeInt(userId);
  11. mRemote.transact(START_SERVICE_TRANSACTION, data, reply, 0);
  12. reply.readException();
  13. ComponentName res = ComponentName.readFromParcel(reply);
  14. data.recycle();
  15. reply.recycle();
  16. return res;
  17. }

这个方法整体上是不是似曾相识,里面的具体流程就不作赘述了。
通过上面的源码对比,发现Service和Activity如此的想象,那既然Service和Activity这么像,为啥还多此一举多弄出来一个Service干什么?原因其实很简单,因为解耦,所以可以跨场景,然后就有一堆理由需要使用Service了,比如:

一些应用程序,始终需要与服务器之间始终保持着心跳连接,就可以使用Service来实现。即使Activity被销毁,或者程序被关闭,只要进程还在,Service就可以继续运行。而且重要的是这个Service可以被任何可以获取Context的地方控制

接下来我们说一下如何控制Service,由前面可知,只要获取Context就可以对Service为所欲为了,以下为实例代码

  1. public void onClick(View v) {
  2. switch (v.getId()) {
  3. case R.id.start_service:
  4. Intent startIntent = new Intent(this, MyService.class);
  5. startService(startIntent);
  6. break;
  7. case R.id.stop_service:
  8. Log.d("MyService", "click Stop Service button");
  9. Intent stopIntent = new Intent(this, MyService.class);
  10. stopService(stopIntent);
  11. break;
  12. case R.id.bind_service:
  13. Intent bindIntent = new Intent(this, MyService.class);
  14. bindService(bindIntent, connection, BIND_AUTO_CREATE);
  15. break;
  16. case R.id.unbind_service:
  17. Log.d("MyService", "click Unbind Service button");
  18. unbindService(connection);
  19. break;
  20. default:
  21. break;
  22. }
  23. }

这里需要注意一点,控制总是成对出现,比如:
第一种情况

startService
stopService

第二种情况

bindService
unbindService

第三种情况

startService
bindService
unbindService
stopService

Service和Thread以及Process区别

不少Android初学者都可能会有这样的疑惑,Service和Thread到底有什么关系呢?什么时候应该用Service,什么时候又应该用Thread?答案可能会有点让你吃惊,因为Service和Thread之间没有任何关系!
之所以有不少人会把它们联系起来,主要就是因为Service的后台概念。Thread我们大家都知道,是用于开启一个子线程,在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候,总会觉得它是用来处理一些后台任务的,一些比较耗时的操作也可以放在这里运行,这就会让人产生混淆了。但是,如果我告诉你Service其实是运行在主线程里的,你还会觉得它和Thread有什么关系吗?

这里不再做实验去验证了,如果你感兴趣的话可以自己去验证。所以说白了,Service既不是线程更不是进程,他只是Android提供给我方便使用的组件而已,千万别联想多了。

本地Service

Service根据功能不同,可以分为本地Service和远程Service,当然还有前台Service和后台Service,后台Service见怪不怪,那么前台Service是什么鬼?这里仅仅举个例子,不做深入,比如墨迹天气,默认显示在通知栏里面,那么如何做到的,你可以Google一下列子很多,我们回归本地和远程Service,有些人可能会联想很多,其实这个本地和远程是相对进程来说的,在同一个进程里就是本地Service,不在同一个进程里就是远程Service。我们知道不同进程间通信和相同进程间通信有着很大区别,最直白的表象就是复杂程度不同,我们先看本地Service如何通信。
[引用代码]

  1. public class MyService extends Service {
  2. public static final String TAG = "MyService";
  3. private MyBinder mBinder = new MyBinder();
  4. @Override
  5. public void onCreate() {
  6. super.onCreate();
  7. Log.d(TAG, "onCreate() executed");
  8. }
  9. @Override
  10. public int onStartCommand(Intent intent, int flags, int startId) {
  11. Log.d(TAG, "onStartCommand() executed");
  12. return super.onStartCommand(intent, flags, startId);
  13. }
  14. @Override
  15. public void onDestroy() {
  16. super.onDestroy();
  17. Log.d(TAG, "onDestroy() executed");
  18. }
  19. @Override
  20. public IBinder onBind(Intent intent) {
  21. return mBinder;
  22. }
  23. class MyBinder extends Binder {
  24. public void startDownload() {
  25. Log.d("TAG", "startDownload() executed");
  26. // 执行具体的下载任务
  27. }
  28. }
  29. }

注意这里MyBinder类继承自Binder类,在其中添加了一个startDownload()公有方法用于在后台执行下载任务。然后这个类的实例mBinder在重载方法onBind中作为返回值返回,这个实例就是Activity和Service之间联系最为紧密的桥梁。

  1. public class MainActivity extends Activity implements OnClickListener {
  2. private Button bindService;
  3. private Button unbindService;
  4. private MyService.MyBinder myBinder;
  5. private ServiceConnection connection = new ServiceConnection() {
  6. @Override
  7. public void onServiceDisconnected(ComponentName name) {
  8. }
  9. @Override
  10. public void onServiceConnected(ComponentName name, IBinder service) {
  11. myBinder = (MyService.MyBinder) service;
  12. myBinder.startDownload();
  13. }
  14. };
  15. @Override
  16. protected void onCreate(Bundle savedInstanceState) {
  17. super.onCreate(savedInstanceState);
  18. setContentView(R.layout.activity_main);
  19. bindService = (Button) findViewById(R.id.bind_service);
  20. unbindService = (Button) findViewById(R.id.unbind_service);
  21. bindService.setOnClickListener(this);
  22. unbindService.setOnClickListener(this);
  23. }
  24. @Override
  25. public void onClick(View v) {
  26. switch (v.getId()) {
  27. case R.id.bind_service:
  28. Intent bindIntent = new Intent(this, MyService.class);
  29. bindService(bindIntent, connection, BIND_AUTO_CREATE);
  30. break;
  31. case R.id.unbind_service:
  32. unbindService(connection);
  33. break;
  34. default:
  35. break;
  36. }
  37. }
  38. }

[此处引用]

可以看到,这里我们首先创建了一个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按钮的点击事件里实现的逻辑。

远程Service

首先我们比较关系如何实现远程Service

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3. package="com.example.servicetest"
  4. android:versionCode="1"
  5. android:versionName="1.0" >
  6. ......
  7. <service
  8. android:name="com.example.servicetest.MyService"
  9. android:process=":remote" >
  10. </service>
  11. </manifest>

通过上面的配置文件,我们知道应该是Service和APP从属于不同的进程,然后比较复杂的就是进程间通信了。

那么如何才能让Activity与一个远程Service建立关联呢?这就要使用AIDL来进行跨进程通信了(IPC)。
AIDL(Android Interface Definition Language)是Android接口定义语言的意思,它可以用于让某个Service与多个应用程序组件之间进行跨进程通信,从而可以实现多个应用程序共享同一个Service的功能。

接下来不准备详细些如何实现进程间通信了,因为Android SDK里面有很多例子可以参考,另外如果对AIDL一点也不熟悉,可以通过Android Service完全解析,关于服务你所需知道的一切(下)这篇文章了解一下.
另外还有一篇博客写的不错Android 中的 Service 全面总结

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注