• android四大组件之service

    Service用于在后台处理一些耗时的逻辑，或者去执行某些需要长期运行的任务。必要的时候我们甚至可以在程序退出的情况下，让Service在后台继续保持运行状态。

    这里主要介绍Service的生命周期，bind绑定，以及AIDL通信

    Android Service的生命周期

    service的生命周期，从它被创建开始，到它被销毁为止，可以有两条不同的路径：

    A started service

    　　被开启的service通过其他组件调用 startService()被创建。

    　　这种service可以无限地运行下去，必须调用stopSelf()方法或者其他组件调用stopService()方法来停止它。

    　　当service被停止时，系统会销毁它。

    A bound service

    　　被绑定的service是当其他组件（一个客户）调用bindService()来创建的。

    　　客户可以通过一个IBinder接口和service进行通信。

    　　客户可以通过 unbindService()方法来关闭这种连接。

    　　一个service可以同时和多个客户绑定，当多个客户都解除绑定之后，系统会销毁service。

    　　这两条路径并不是完全分开的。

    　　即是说，你可以和一个已经调用了 startService()而被开启的service进行绑定。

    　　比如，一个后台音乐service可能因调用 startService()方法而被开启了，稍后，可能用户想要控制播放器或者得到一些当前歌曲的信息，可以通过bindService()将一个activity和service绑定。这种情况下，stopService()或 stopSelf()实际上并不能停止这个service，除非所有的客户都解除绑定。

    Implementing the lifecycle callbacks

    　　和activity一样，service也有一系列的生命周期回调函数，你可以实现它们来监测service状态的变化，并且在适当的时候执行适当的工作。

    　　下面的service展示了每一个生命周期的方法：

    复制代码
    public class ExampleService extends Service
{
    int mStartMode; // indicates how to behave if the service is killed
    IBinder mBinder; // interface for clients that bind
    boolean mAllowRebind; // indicates whether onRebind should be used

    @Override
    public void onCreate()
    {
        // The service is being created
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        // The service is starting, due to a call to startService()
        return mStartMode;
    }

    @Override
    public IBinder onBind(Intent intent)
    {
        // A client is binding to the service with bindService()
        return mBinder;
    }

    @Override
    public boolean onUnbind(Intent intent)
    {
        // All clients have unbound with unbindService()
        return mAllowRebind;
    }

    @Override
    public void onRebind(Intent intent)
    {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }

    @Override
    public void onDestroy()
    {
        // The service is no longer used and is being destroyed
    }
}
    复制代码

    　　不像是activity的生命周期回调函数，你不需要调用基类的实现。

     

    　　这个图说明了service典型的回调方法，尽管这个图中将开启的service和绑定的service分开，但是你需要记住，任何service都潜在地允许绑定。

    　　所以，一个被开启的service仍然可能被绑定。

    　　实现这些方法，你可以看到两层嵌套的service的生命周期：

    The entire lifetime

    　　service整体的生命时间是从onCreate()被调用开始，到onDestroy()方法返回为止。

    　　和activity一样，service在onCreate()中进行它的初始化工作，在onDestroy()中释放残留的资源。

    　　比如，一个音乐播放service可以在onCreate()中创建播放音乐的线程，在onDestory()中停止这个线程。

     　　onCreate() 和 onDestroy()会被所有的service调用，不论service是通过startService()还是bindService()建立。

    The active lifetime

    　　service积极活动的生命时间（active lifetime）是从onStartCommand() 或onBind()被调用开始，它们各自处理由startService()或 bindService()方法传过来的Intent对象。

    　　如果service是被开启的，那么它的活动生命周期和整个生命周期一同结束。

    　　如果service是被绑定的，它们它的活动生命周期是在onUnbind()方法返回后结束。

    　　注意：尽管一个被开启的service是通过调用 stopSelf() 或 stopService()来停止的，没有一个对应的回调函数与之对应，即没有onStop()回调方法。所以，当调用了停止的方法，除非这个service和客户组件绑定，否则系统将会直接销毁它，onDestory()方法会被调用，并且是这个时候唯一会被调用的回调方法。

    Managing the Lifecycle of a Bound Service

    　　当绑定service和所有客户端解除绑定之后，Android系统将会销毁它，（除非它同时被onStartCommand()方法开启）。

    　　因此，如果你的service是一个纯粹的绑定service，那么你不需要管理它的生命周期。

    　　然而，如果你选择实现onStartCommand()回调方法，那么你必须显式地停止service，因为service此时被看做是开启的。

    　　这种情况下，service会一直运行到它自己调用 stopSelf()或另一个组件调用stopService()，不论它是否和客户端绑定。

    　　另外，如果你的service被开启并且接受绑定，那么当系统调用你的 onUnbind()方法时，如果你想要在下次客户端绑定的时候接受一个onRebind()的调用（而不是调用 onBind()），你可以选择在 onUnbind()中返回true。

    　　onRebind()的返回值为void，但是客户端仍然在它的 onServiceConnected()回调方法中得到 IBinder 对象。

    　　下图展示了这种service（被开启，还允许绑定）的生命周期：

    Service的基本使用方法、bind绑定以及AIDL通信

    Service的基本用法

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

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

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

    [java] view plaincopy
     
    1. public class MyService extends Service {  
    2.   
    3.     public static final String TAG = "MyService";  
    4.   
    5.     @Override  
    6.     public void onCreate() {  
    7.         super.onCreate();  
    8.         Log.d(TAG, "onCreate() executed");  
    9.     }  
    10.   
    11.     @Override  
    12.     public int onStartCommand(Intent intent, int flags, int startId) {  
    13.         Log.d(TAG, "onStartCommand() executed");  
    14.         return super.onStartCommand(intent, flags, startId);  
    15.     }  
    16.       
    17.     @Override  
    18.     public void onDestroy() {  
    19.         super.onDestroy();  
    20.         Log.d(TAG, "onDestroy() executed");  
    21.     }  
    22.   
    23.     @Override  
    24.     public IBinder onBind(Intent intent) {  
    25.         return null;  
    26.     }  
    27.   
    28. }  

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

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

    [html] view plaincopy
     
    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     android:layout_width="match_parent"  
    3.     android:layout_height="match_parent"  
    4.     android:orientation="vertical" >  
    5.   
    6.     <Button  
    7.         android:id="@+id/start_service"  
    8.         android:layout_width="match_parent"  
    9.         android:layout_height="wrap_content"  
    10.         android:text="Start Service" />  
    11.   
    12.     <Button  
    13.         android:id="@+id/stop_service"  
    14.         android:layout_width="match_parent"  
    15.         android:layout_height="wrap_content"  
    16.         android:text="Stop Service" />  
    17.   
    18. </LinearLayout>  

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

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

    [java] view plaincopy
     
    1. public class MainActivity extends Activity implements OnClickListener {  
    2.   
    3.     private Button startService;  
    4.   
    5.     private Button stopService;  
    6.   
    7.     @Override  
    8.     protected void onCreate(Bundle savedInstanceState) {  
    9.         super.onCreate(savedInstanceState);  
    10.         setContentView(R.layout.activity_main);  
    11.         startService = (Button) findViewById(R.id.start_service);  
    12.         stopService = (Button) findViewById(R.id.stop_service);  
    13.         startService.setOnClickListener(this);  
    14.         stopService.setOnClickListener(this);  
    15.     }  
    16.   
    17.     @Override  
    18.     public void onClick(View v) {  
    19.         switch (v.getId()) {  
    20.         case R.id.start_service:  
    21.             Intent startIntent = new Intent(this, MyService.class);  
    22.             startService(startIntent);  
    23.             break;  
    24.         case R.id.stop_service:  
    25.             Intent stopIntent = new Intent(this, MyService.class);  
    26.             stopService(stopIntent);  
    27.             break;  
    28.         default:  
    29.             break;  
    30.         }  
    31.     }  
    32.   
    33. }  

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

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

    [html] view plaincopy
     
    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.     <uses-sdk  
    8.         android:minSdkVersion="14"  
    9.         android:targetSdkVersion="17" />  
    10.   
    11.     <application  
    12.         android:allowBackup="true"  
    13.         android:icon="@drawable/ic_launcher"  
    14.         android:label="@string/app_name"  
    15.         android:theme="@style/AppTheme" >  
    16.           
    17.     ……  
    18.   
    19.         <service android:name="com.example.servicetest.MyService" >  
    20.         </service>  
    21.     </application>  
    22.   
    23. </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 plaincopy
     
    1. public class MyService extends Service {  
    2.   
    3.     public static final String TAG = "MyService";  
    4.   
    5.     private MyBinder mBinder = new MyBinder();  
    6.   
    7.     @Override  
    8.     public void onCreate() {  
    9.         super.onCreate();  
    10.         Log.d(TAG, "onCreate() executed");  
    11.     }  
    12.   
    13.     @Override  
    14.     public int onStartCommand(Intent intent, int flags, int startId) {  
    15.         Log.d(TAG, "onStartCommand() executed");  
    16.         return super.onStartCommand(intent, flags, startId);  
    17.     }  
    18.   
    19.     @Override  
    20.     public void onDestroy() {  
    21.         super.onDestroy();  
    22.         Log.d(TAG, "onDestroy() executed");  
    23.     }  
    24.   
    25.     @Override  
    26.     public IBinder onBind(Intent intent) {  
    27.         return mBinder;  
    28.     }  
    29.   
    30.     class MyBinder extends Binder {  
    31.   
    32.         public void startDownload() {  
    33.             Log.d("TAG", "startDownload() executed");  
    34.             // 执行具体的下载任务  
    35.         }  
    36.   
    37.     }  
    38.   
    39. }  

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

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

    [html] view plaincopy
     
    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     android:layout_width="match_parent"  
    3.     android:layout_height="match_parent"  
    4.     android:orientation="vertical" >  
    5.   
    6.     <Button  
    7.         android:id="@+id/start_service"  
    8.         android:layout_width="match_parent"  
    9.         android:layout_height="wrap_content"  
    10.         android:text="Start Service" />  
    11.   
    12.     <Button  
    13.         android:id="@+id/stop_service"  
    14.         android:layout_width="match_parent"  
    15.         android:layout_height="wrap_content"  
    16.         android:text="Stop Service" />  
    17.   
    18.     <Button  
    19.         android:id="@+id/bind_service"  
    20.         android:layout_width="match_parent"  
    21.         android:layout_height="wrap_content"  
    22.         android:text="Bind Service" />  
    23.       
    24.     <Button   
    25.         android:id="@+id/unbind_service"  
    26.         android:layout_width="match_parent"  
    27.         android:layout_height="wrap_content"  
    28.         android:text="Unbind Service"  
    29.         />  
    30.       
    31. </LinearLayout>  

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

    [java] view plaincopy
     
    1. public class MainActivity extends Activity implements OnClickListener {  
    2.   
    3.     private Button startService;  
    4.   
    5.     private Button stopService;  
    6.   
    7.     private Button bindService;  
    8.   
    9.     private Button unbindService;  
    10.   
    11.     private MyService.MyBinder myBinder;  
    12.   
    13.     private ServiceConnection connection = new ServiceConnection() {  
    14.   
    15.         @Override  
    16.         public void onServiceDisconnected(ComponentName name) {  
    17.         }  
    18.   
    19.         @Override  
    20.         public void onServiceConnected(ComponentName name, IBinder service) {  
    21.             myBinder = (MyService.MyBinder) service;  
    22.             myBinder.startDownload();  
    23.         }  
    24.     };  
    25.   
    26.     @Override  
    27.     protected void onCreate(Bundle savedInstanceState) {  
    28.         super.onCreate(savedInstanceState);  
    29.         setContentView(R.layout.activity_main);  
    30.         startService = (Button) findViewById(R.id.start_service);  
    31.         stopService = (Button) findViewById(R.id.stop_service);  
    32.         bindService = (Button) findViewById(R.id.bind_service);  
    33.         unbindService = (Button) findViewById(R.id.unbind_service);  
    34.         startService.setOnClickListener(this);  
    35.         stopService.setOnClickListener(this);  
    36.         bindService.setOnClickListener(this);  
    37.         unbindService.setOnClickListener(this);  
    38.     }  
    39.   
    40.     @Override  
    41.     public void onClick(View v) {  
    42.         switch (v.getId()) {  
    43.         case R.id.start_service:  
    44.             Intent startIntent = new Intent(this, MyService.class);  
    45.             startService(startIntent);  
    46.             break;  
    47.         case R.id.stop_service:  
    48.             Intent stopIntent = new Intent(this, MyService.class);  
    49.             stopService(stopIntent);  
    50.             break;  
    51.         case R.id.bind_service:  
    52.             Intent bindIntent = new Intent(this, MyService.class);  
    53.             bindService(bindIntent, connection, BIND_AUTO_CREATE);  
    54.             break;  
    55.         case R.id.unbind_service:  
    56.             unbindService(connection);  
    57.             break;  
    58.         default:  
    59.             break;  
    60.         }  
    61.     }  
    62.   
    63. }  

    可以看到，这里我们首先创建了一个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 plaincopy
     
    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. }  

    然后重新运行程序，先点击一下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 plaincopy
     
    1. Log.d("MyService", "MainActivity thread id is " + Thread.currentThread().getId());  

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

    [java] view plaincopy
     
    1. 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 plaincopy
     
    1. @Override  
    2. public int onStartCommand(Intent intent, int flags, int startId) {  
    3.     new Thread(new Runnable() {  
    4.         @Override  
    5.         public void run() {  
    6.             // 开始执行后台任务  
    7.         }  
    8.     }).start();  
    9.     return super.onStartCommand(intent, flags, startId);  
    10. }  
    11.   
    12. class MyBinder extends Binder {  
    13.   
    14.     public void startDownload() {  
    15.         new Thread(new Runnable() {  
    16.             @Override  
    17.             public void run() {  
    18.                 // 执行具体的下载任务  
    19.             }  
    20.         }).start();  
    21.     }  
    22.   
    23. }  

    创建前台Service

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

                                                       

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

    [java] view plaincopy
     
    1. public class MyService extends Service {  
    2.   
    3.     public static final String TAG = "MyService";  
    4.   
    5.     private MyBinder mBinder = new MyBinder();  
    6.   
    7.     @Override  
    8.     public void onCreate() {  
    9.         super.onCreate();  
    10.         Notification notification = new Notification(R.drawable.ic_launcher,  
    11.                 "有通知到来", System.currentTimeMillis());  
    12.         Intent notificationIntent = new Intent(this, MainActivity.class);  
    13.         PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,  
    14.                 notificationIntent, 0);  
    15.         notification.setLatestEventInfo(this, "这是通知的标题", "这是通知的内容",  
    16.                 pendingIntent);  
    17.         startForeground(1, notification);  
    18.         Log.d(TAG, "onCreate() executed");  
    19.     }  
    20.   
    21.     .........  
    22.   
    23. }  

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

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

                                                       

    好了，由于篇幅的原因，本篇文章就先写到这里。目前我们已经把关于Service的很多重要知识点都梳理完了，下一篇文章会承接这篇文章，介绍Android Service中剩下的一个非常重要且复杂的知识点 —— 远程Service的使用，感兴趣的朋友请继续阅读 Android Service完全解析，关于服务你所需知道的一切（下） 。

      

    Android Service完全解析，关于服务你所需知道的一切(下)

    分类： Android疑难解析2013-11-07 08:32 4320人阅读 评论(39) 收藏 举报
    AndroidServiceAIDLIPCremote

    转载请注册出处：http://blog.csdn.net/guolin_blog/article/details/9797169

    在上一篇文章中，我们学习了Android Service相关的许多重要内容，包括Service的基本用法、Service和Activity进行通信、Service的销毁方式、Service与Thread的关系、以及如何创建前台Service。以上所提到的这些知识点，基本上涵盖了大部分日常开发工作当中可能使用到的Service技术。不过关于Service其实还有一个更加高端的使用技巧没有介绍，即远程Service的用法。使用远程Service甚至可以实现Android跨进程通信的功能，下面就让我们具体地学习一下。

    如果你还没有看过前面一篇文章，建议先去阅读一下 Android Service完全解析，关于服务你所需知道的一切（上） ，因为本篇文章中涉及到的代码是在上篇文章的基础上进行修改的。

    在上篇文章中我们知道了，Service其实是运行在主线程里的，如果直接在Service中处理一些耗时的逻辑，就会导致程序ANR。

    让我们来做个实验验证一下吧，修改上一篇文章中创建的ServiceTest项目，在MyService的onCreate()方法中让线程睡眠60秒，如下所示：

    [java] view plaincopy
     
    1. public class MyService extends Service {  
    2.   
    3.     ......  
    4.   
    5.     @Override  
    6.     public void onCreate() {  
    7.         super.onCreate();  
    8.         Log.d(TAG, "onCreate() executed");  
    9.         try {  
    10.             Thread.sleep(60000);  
    11.         } catch (InterruptedException e) {  
    12.             e.printStackTrace();  
    13.         }  
    14.     }  
    15.       
    16.     ......  
    17.   
    18. }  

    重新运行后，点击一下Start Service按钮或Bind Service按钮，程序就会阻塞住并无法进行任何其它操作，过一段时间后就会弹出ANR的提示框，如下图所示。

                                                            

    之前我们提到过，应该在Service中开启线程去执行耗时任务，这样就可以有效地避免ANR的出现。

    那么本篇文章的主题是介绍远程Service的用法，如果将MyService转换成一个远程Service，还会不会有ANR的情况呢？让我们来动手尝试一下吧。

    将一个普通的Service转换成远程Service其实非常简单，只需要在注册Service的时候将它的android:process属性指定成:remote就可以了，代码如下所示：

    [html] view plaincopy
     
    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.     ......  
    8.       
    9.     <service  
    10.         android:name="com.example.servicetest.MyService"  
    11.         android:process=":remote" >  
    12.     </service>  
    13.   
    14. </manifest>  
    现在重新运行程序，并点击一下Start Service按钮，你会看到控制台立刻打印了onCreate() executed的信息，而且主界面并没有阻塞住，也不会出现ANR。大概过了一分钟后，又会看到onStartCommand() executed打印了出来。

    为什么将MyService转换成远程Service后就不会导致程序ANR了呢？这是由于，使用了远程Service后，MyService已经在另外一个进程当中运行了，所以只会阻塞该进程中的主线程，并不会影响到当前的应用程序。
    为了证实一下MyService现在确实已经运行在另外一个进程当中了，我们分别在MainActivity的onCreate()方法和MyService的onCreate()方法里加入一行日志，打印出各自所在的进程id，如下所示：

    [java] view plaincopy
     
    1. Log.d("TAG", "process id is " + Process.myPid());  
    再次重新运行程序，然后点击一下Start Service按钮，打印结果如下图所示：

                           

    可以看到，不仅仅是进程id不同了，就连应用程序包名也不一样了，MyService中打印的那条日志，包名后面还跟上了:remote标识。

    那既然远程Service这么好用，干脆以后我们把所有的Service都转换成远程Service吧，还省得再开启线程了。其实不然，远程Service非但不好用，甚至可以称得上是较为难用。一般情况下如果可以不使用远程Service，就尽量不要使用它。

    下面就来看一下它的弊端吧，首先将MyService的onCreate()方法中让线程睡眠的代码去除掉，然后重新运行程序，并点击一下Bind Service按钮，你会发现程序崩溃了！为什么点击Start Service按钮程序就不会崩溃，而点击Bind Service按钮就会崩溃呢？这是由于在Bind Service按钮的点击事件里面我们会让MainActivity和MyService建立关联，但是目前MyService已经是一个远程Service了，Activity和Service运行在两个不同的进程当中，这时就不能再使用传统的建立关联的方式，程序也就崩溃了。

    那么如何才能让Activity与一个远程Service建立关联呢？这就要使用AIDL来进行跨进程通信了（IPC）。

    AIDL（Android Interface Definition Language）是Android接口定义语言的意思，它可以用于让某个Service与多个应用程序组件之间进行跨进程通信，从而可以实现多个应用程序共享同一个Service的功能。

    下面我们就来一步步地看一下AIDL的用法到底是怎样的。首先需要新建一个AIDL文件，在这个文件中定义好Activity需要与Service进行通信的方法。新建MyAIDLService.aidl文件，代码如下所示：

    [java] view plaincopy
     
    1. package com.example.servicetest;  
    2. interface MyAIDLService {  
    3.     int plus(int a, int b);  
    4.     String toUpperCase(String str);  
    5. }  
    点击保存之后，gen目录下就会生成一个对应的Java文件，如下图所示：

                                                 

    然后修改MyService中的代码，在里面实现我们刚刚定义好的MyAIDLService接口，如下所示：

    [java] view plaincopy
     
    1. public class MyService extends Service {  
    2.   
    3.     ......  
    4.   
    5.     @Override  
    6.     public IBinder onBind(Intent intent) {  
    7.         return mBinder;  
    8.     }  
    9.   
    10.     MyAIDLService.Stub mBinder = new Stub() {  
    11.   
    12.         @Override  
    13.         public String toUpperCase(String str) throws RemoteException {  
    14.             if (str != null) {  
    15.                 return str.toUpperCase();  
    16.             }  
    17.             return null;  
    18.         }  
    19.   
    20.         @Override  
    21.         public int plus(int a, int b) throws RemoteException {  
    22.             return a + b;  
    23.         }  
    24.     };  
    25.   
    26. }  
    这里先是对MyAIDLService.Stub进行了实现，重写里了toUpperCase()和plus()这两个方法。这两个方法的作用分别是将一个字符串全部转换成大写格式，以及将两个传入的整数进行相加。然后在onBind()方法中将MyAIDLService.Stub的实现返回。这里为什么可以这样写呢？因为Stub其实就是Binder的子类，所以在onBind()方法中可以直接返回Stub的实现。

    接下来修改MainActivity中的代码，如下所示：

    [java] view plaincopy
     
    1. public class MainActivity extends Activity implements OnClickListener {  
    2.   
    3.     private Button startService;  
    4.   
    5.     private Button stopService;  
    6.   
    7.     private Button bindService;  
    8.   
    9.     private Button unbindService;  
    10.       
    11.     private MyAIDLService myAIDLService;  
    12.   
    13.     private ServiceConnection connection = new ServiceConnection() {  
    14.   
    15.         @Override  
    16.         public void onServiceDisconnected(ComponentName name) {  
    17.         }  
    18.   
    19.         @Override  
    20.         public void onServiceConnected(ComponentName name, IBinder service) {  
    21.             myAIDLService = MyAIDLService.Stub.asInterface(service);  
    22.             try {  
    23.                 int result = myAIDLService.plus(3, 5);  
    24.                 String upperStr = myAIDLService.toUpperCase("hello world");  
    25.                 Log.d("TAG", "result is " + result);  
    26.                 Log.d("TAG", "upperStr is " + upperStr);  
    27.             } catch (RemoteException e) {  
    28.                 e.printStackTrace();  
    29.             }  
    30.         }  
    31.     };  
    32.   
    33.     ......  
    34.   
    35. }  
    我们只是修改了ServiceConnection中的代码。可以看到，这里首先使用了MyAIDLService.Stub.asInterface()方法将传入的IBinder对象传换成了MyAIDLService对象，接下来就可以调用在MyAIDLService.aidl文件中定义的所有接口了。这里我们先是调用了plus()方法，并传入了3和5作为参数，然后又调用了toUpperCase()方法，并传入hello world字符串作为参数，最后将调用方法的返回结果打印出来。

    现在重新运行程序，并点击一下Bind Service按钮，可以看到打印日志如下所示：

                                   

    由此可见，我们确实已经成功实现跨进程通信了，在一个进程中访问到了另外一个进程中的方法。

    不过你也可以看出，目前的跨进程通信其实并没有什么实质上的作用，因为这只是在一个Activity里调用了同一个应用程序的Service里的方法。而跨进程通信的真正意义是为了让一个应用程序去访问另一个应用程序中的Service，以实现共享Service的功能。那么下面我们自然要学习一下，如何才能在其它的应用程序中调用到MyService里的方法。

    在上一篇文章中我们已经知道，如果想要让Activity与Service之间建立关联，需要调用bindService()方法，并将Intent作为参数传递进去，在Intent里指定好要绑定的Service，示例代码如下：

    [java] view plaincopy
     
    1. Intent bindIntent = new Intent(this, MyService.class);  
    2. bindService(bindIntent, connection, BIND_AUTO_CREATE);  
    这里在构建Intent的时候是使用MyService.class来指定要绑定哪一个Service的，但是在另一个应用程序中去绑定Service的时候并没有MyService这个类，这时就必须使用到隐式Intent了。现在修改AndroidManifest.xml中的代码，给MyService加上一个action，如下所示：
    [html] view plaincopy
     
    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.     ......  
    8.   
    9.     <service  
    10.         android:name="com.example.servicetest.MyService"  
    11.         android:process=":remote" >  
    12.         <intent-filter>  
    13.             <action android:name="com.example.servicetest.MyAIDLService"/>  
    14.         </intent-filter>  
    15.     </service>  
    16.   
    17. </manifest>  

    这就说明，MyService可以响应带有com.example.servicetest.MyAIDLService这个action的Intent。

    现在重新运行一下程序，这样就把远程Service端的工作全部完成了。

    然后创建一个新的Android项目，起名为ClientTest，我们就尝试在这个程序中远程调用MyService中的方法。

    ClientTest中的Activity如果想要和MyService建立关联其实也不难，首先需要将MyAIDLService.aidl文件从ServiceTest项目中拷贝过来，注意要将原有的包路径一起拷贝过来，完成后项目的结构如下图所示：

                                         

    然后打开或新建activity_main.xml，在布局文件中也加入一个Bind Service按钮：

    [html] view plaincopy
     
    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     android:layout_width="match_parent"  
    3.     android:layout_height="match_parent"  
    4.     android:orientation="vertical"  
    5.      >  
    6.   
    7.    <Button   
    8.        android:id="@+id/bind_service"  
    9.        android:layout_width="match_parent"  
    10.        android:layout_height="wrap_content"  
    11.        android:text="Bind Service"  
    12.        />  
    13.   
    14. </LinearLayout>  
    接下来打开或新建MainActivity，在其中加入和MyService建立关联的代码，如下所示：
    [java] view plaincopy
     
    1. public class MainActivity extends Activity {  
    2.   
    3.     private MyAIDLService myAIDLService;  
    4.   
    5.     private ServiceConnection connection = new ServiceConnection() {  
    6.   
    7.         @Override  
    8.         public void onServiceDisconnected(ComponentName name) {  
    9.         }  
    10.   
    11.         @Override  
    12.         public void onServiceConnected(ComponentName name, IBinder service) {  
    13.             myAIDLService = MyAIDLService.Stub.asInterface(service);  
    14.             try {  
    15.                 int result = myAIDLService.plus(50, 50);  
    16.                 String upperStr = myAIDLService.toUpperCase("comes from ClientTest");  
    17.                 Log.d("TAG", "result is " + result);  
    18.                 Log.d("TAG", "upperStr is " + upperStr);  
    19.             } catch (RemoteException e) {  
    20.                 e.printStackTrace();  
    21.             }  
    22.         }  
    23.     };  
    24.   
    25.     @Override  
    26.     protected void onCreate(Bundle savedInstanceState) {  
    27.         super.onCreate(savedInstanceState);  
    28.         setContentView(R.layout.activity_main);  
    29.         Button bindService = (Button) findViewById(R.id.bind_service);  
    30.         bindService.setOnClickListener(new OnClickListener() {  
    31.             @Override  
    32.             public void onClick(View v) {  
    33.                 Intent intent = new Intent("com.example.servicetest.MyAIDLService");  
    34.                 bindService(intent, connection, BIND_AUTO_CREATE);  
    35.             }  
    36.         });  
    37.     }  
    38.   
    39. }  
    这部分代码大家一定会非常眼熟吧？没错，这和在ServiceTest的MainActivity中的代码几乎是完全相同的，只是在让Activity和Service建立关联的时候我们使用了隐式Intent，将Intent的action指定成了com.example.servicetest.MyAIDLService。

    在当前Activity和MyService建立关联之后，我们仍然是调用了plus()和toUpperCase()这两个方法，远程的MyService会对传入的参数进行处理并返回结果，然后将结果打印出来。

    这样的话，ClientTest中的代码也就全部完成了，现在运行一下这个项目，然后点击Bind Service按钮，此时就会去和远程的MyService建立关联，观察LogCat中的打印信息如下所示：

                                

    不用我说，大家都已经看出，我们的跨进程通信功能已经完美实现了。

    不过还有一点需要说明的是，由于这是在不同的进程之间传递数据，Android对这类数据的格式支持是非常有限的，基本上只能传递Java的基本数据类型、字符串、List或Map等。那么如果我想传递一个自定义的类该怎么办呢？这就必须要让这个类去实现Parcelable接口，并且要给这个类也定义一个同名的AIDL文件。这部分内容并不复杂，而且和Service关系不大，所以就不再详细进行讲解了，感兴趣的朋友可以自己去查阅一下相关的资料。

    好了，结合上下两篇，这就是关于Service你所需知道的一切。
  • 相关阅读:
    python第二十四课——set中的函数
    python第二十三课——dict中的函数
    python第二十二课——list函数
    10 编译PHP并与nginx整合
    09 nginx Rewrite(重写)详细解析
    07 nginx Location之正则匹配
    06 nginx Location详解之精准匹配
    JQ 修改样式
    05 nginx定时任务完成日志切割
    linux 时间与本地时间不对应解决办法
  • 原文地址：https://www.cnblogs.com/ymczxy/p/4710630.html
Copyright © 2020-2023  润新知