Android Service详解

小鱼儿 2022-08-11 20:59 174阅读 0赞

*  **Android Service 没有固定的用户界面，而是默认的运行在后台，例如：播放背景音乐、从网络下载数据、计算数据并提供给activity。**

*  本文向大家介绍Android Service ，可能好多人还不了解Android Service的服务的种种特性，没有关系，看完本文你肯定有不少收获，掌握了Android Service 这们服务会使我们的编程工作更简单和更轻松。
    
    常见的例子：media player 从播放列表播放音乐，播放器有一些activities来叫用户选定歌曲并开始播放。但是，播放本身不需要activity处理，因为用户希望关闭activity后歌曲会继续播放。
    
    因此media player 的activity 会启动一个service 。当用户离开窗体后，系统还可以保持歌曲的播放。可以与正在运行的service通信或者启动一个service 。与service通信依赖于service公开的接口。例如音乐播放，接口可能允许用户暂停、启动、停止、继续播放列表。
    
    象activities和其他组件一样，Android Service 运行在应用程序的主线程。因此他们不会阻塞其他的组件或者用户界面。可以在服务中启用另外的线程来做耗时的工作，如音乐播放。请参见Processes and Threads.
    
    Broadcast receivers   
    [Android][] Service 是一个接收并处理广播通知（broadcast announcements）的组件。多数的广播是系统发起的。如地域变幻、电池电量不足、图片获取、语言转换。程序也可以初始化一个广播，例如让其他的程序知道他们需要的某些数据被下载了。（注：通知广播即事件）
    
    程序可以有任意数量的broadcast receivers 来相应它觉得重要的通知。所有的receivers 继承自 BroadcastReceiver 类。Broadcast receivers 不会显示用户界面，但是他们可能启动一个activity 来相应收到的通知。
    
    或者使用 NotificationManager 通知用户。 可以通过多种方式通知用户－开启背景灯、振动设备、播放声音等。最典型的是在状态栏显示一个图标，这样用户就可以点它打开看通知内容。
    
    Content providers   
    Android Service 创建其他程序使用的数据集。数据可以存在系统的SQLite数据库或者其他地方。content provider 继承自 ContentProvider 类。
    
    实现一组标准的方法，来使其他程序可以存取数据。但是，程序并不是直接调用这些方法，而是使用ContentResolver 对象来调用这些方法。ContentResolve的作用是管理provider和程序之间的多进程交互。
    
    请参见 Content Providers 文档。   
    只要有需要调用特定组件的需求，Android就需要确保组件的程序进程正在运行，如果组件的线程没有启动，还要启动所需的进程。如果所需组件没有初始化，Android也会把它初始化。
    
    当ContentResolver 发起一个请求的时候Content providers 激活. 另外三个组件： — activities, services, 和 broadcast receivers — 被叫做intents的异步的消息激活。intent 是一个保持了消息信息的 Intent 对象。对于activities 和 services,它传送了被请求的数据和特定的URI。
    
    例如，它可能传达一个请求，叫activity来呈现一个图片或者叫用户编辑某段文本。对于broadcast receivers，Internt对象传送了通知的动作。例如，它可能通知相机的按钮被按下。
    
    Service是在一段不定的时间运行在后台，不和用户交互应用组件。每个Service必须在manifest中 通过<service>来声明。可以通过contect.startservice和contect.bindserverice来启动。
    
        Service和其他的应用组件一样，运行在进程的主线程中。这就是说如果service需要很多耗时或者阻塞的操作，需要在其子线程中实现。
    
      
    
    
        service的两种模式（startService()/bindService()不是完全分离的）：
    
     *  本地服务 Local Service 用于应用程序内部。  
          它可以启动并运行，直至有人停止了它或它自己停止。在这种方式下，它以调用Context.startService()启动，而以调用Context.stopService()结束。它可以调用Service.stopSelf() 或 Service.stopSelfResult()来自己停止。不论调用了多少次startService()方法，你只需要调用一次stopService()来停止服务。  
          用于实现应用程序自己的一些耗时任务，比如查询升级信息，并不占用应用程序比如Activity所属线程，而是单开线程后台执行，这样用户体验比较好。
     *  远程服务 Remote Service 用于android系统内部的应用程序之间。  
          它可以通过自己定义并暴露出来的接口进行程序操作。客户端建立一个到服务对象的连接，并通过那个连接来调用服务。连接以调用Context.bindService()方法建立，以调用 Context.unbindService()关闭。多个客户端可以绑定至同一个服务。如果服务此时还没有加载，bindService()会先加载它。  
          可被其他应用程序复用，比如天气预报服务，其他应用程序不需要再写这样的服务，调用已有的即可。
    
      
    
    
    生命周期
    
        Service的生命周期并不像Activity那么复杂，它只继承了onCreate(),onStart(),onDestroy()三个方法，当我们第一次启动Service时，先后调用了onCreate(),onStart()这两个方法，当停止Service时，则执行onDestroy()方法，这里需要注意的是，如果Service已经启动了，当我们再次启动Service时，不会在执行onCreate()方法，而是直接执行onStart()方法。
    
      
    
    
        而启动service，根据onStartCommand的返回值不同，有两个附加的模式：
    
        1. START\_STICKY 用于显示启动和停止service。
    
        2. START\_NOT\_STICKY或START\_REDELIVER\_INTENT用于有命令需要处理时才运行的模式。
    
      
    
    
         服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。  
        1. 使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。  
        如果打算采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。  
        如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStart()方法。  
        采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。
    
      
        2. 使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。  
        onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。  
        采用Context.bindService()方法启动服务时只能调用onUnbind()方法解除调用者与服务解除，服务结束时会调用onDestroy()方法。
    
      
    
    
    看看官方给出的比较流程示意图：  
    ![&\#20004;&\#31181;&\#27604;&\#36739;][20004_31181_27604_36739]  
    
    
      
    
    
        官方文档告诉我们，一个service可以同时start并且bind，在这样的情况，系统会一直保持service的运行状态如果service已经start了或者BIND\_AUTO\_CREATE标志被设置。如果没有一个条件满足，那么系统将会调用onDestory方法来终止service.所有的清理工作（终止线程，反注册接收器）都在onDestory中完成。
    
      
    
    
    拥有service的进程具有较高的优先级
    
        官方文档告诉我们，Android系统会尽量保持拥有service的进程运行，只要在该service已经被启动(start)或者客户端连接(bindService)到它。当内存不足时，需要保持，拥有service的进程具有较高的优先级。   
    
    
      
    
    
    1． 如果service正在调用onCreate,onStartCommand或者onDestory方法，那么用于当前service的进程则变为前台进程以避免被killed。  
      
    2． 如果当前service已经被启动(start)，拥有它的进程则比那些用户可见的进程优先级低一些，但是比那些不可见的进程更重要，这就意味着service一般不会被killed.  
      
    3． 如果客户端已经连接到service (bindService),那么拥有Service的进程则拥有最高的优先级，可以认为service是可见的。  
      
    4． 如果service可以使用startForeground(int, Notification)方法来将service设置为前台状态，那么系统就认为是对用户可见的，并不会在内存不足时killed。  
    
    
      
    
    
    如果有其他的应用组件作为Service,Activity等运行在相同的进程中，那么将会增加该进程的重要性。
    
      
    
    
    本地service
    
    1.不需和Activity交互的本地服务
    
    public  class LocalService  extends \{   
      
             private  static  final String TAG =  "LocalService";   
      
            @Override   
             public IBinder onBind(Intent intent) \{   
                    Log.i(TAG,  "onBind");   
                     return  null;   
            \}   
      
            @Override   
             public  void onCreate() \{   
                    Log.i(TAG,  "onCreate");   
                     super.onCreate();   
            \}   
      
            @Override   
             public  void onDestroy() \{   
                    Log.i(TAG,  "onDestroy");   
                     super.onDestroy();   
            \}   
      
            @Override   
             public  void onStart(Intent intent,  int startId) \{   
                    Log.i(TAG,  "onStart");   
                     super.onStart(intent, startId);   
            \}   
    \}
    
      
    
    
    Activity:  
    
    
    public  class ServiceActivity  extends Activity \{   
      
            @Override   
             protected  void onCreate(Bundle savedInstanceState) \{   
                     super.onCreate(savedInstanceState);   
                    setContentView(R.layout.servicedemo);   
      
                    ((Button) findViewById(R.id.startLocalService)).setOnClickListener(   
                                     new View.OnClickListener()\{   
      
                                            @Override   
                                             public  void onClick(View view) \{   
                                                     // TODO Auto-generated method stub   
                                                    startService(new Intent("com.demo.SERVICE\_DEMO"));   
                                            \}    
                                    \});   
      
                    ((Button) findViewById(R.id.stopLocalService)).setOnClickListener(   
                                     new View.OnClickListener()\{   
      
                                            @Override   
                                             public  void onClick(View view) \{   
                                                     // TODO Auto-generated method stub   
                                                     stopService(new Intent("com.demo.SERVICE\_DEMO"));   
                                            \}   
                                    \});   
            \}   
      
    \}
    
      
    
    
    在AndroidManifest.xml添加：
    
    < service  android:name =".LocalService" >   
             < intent-filter >   
                     < action  android:name ="com.demo.SERVICE\_DEMO"  />   
                     < category  android:name ="android.intent.category.default"  />   
             </ intent-filter >   
    </ service >
    
    否则启动服务时会提示new Intent找不到"com.demo.SERVICE\_DEMO"。
    
      
    
    
        对于这类不需和Activity交互的本地服务，是使用startService/stopService的最好例子。
    
        运行时可以发现第一次startService时，会调用onCreate和onStart，在没有stopService前，无论点击多少次startService，都只会调用onStart。而stopService时调用onDestroy。再次点击stopService，会发现不会进入service的生命周期的，即不会再调用onCreate，onStart和onDestroy。
    
        而onBind在startService/stopService中没有调用。
    
      
    
    
    2.本地服务和Activity交互
    
        对于这种case，官方的sample(APIDemo\\app.LocalService)是最好的例子:
    
    /\*\*   
    \* This is an example of implementing an application service that runs locally   
    \* in the same process as the application.    The \{@link LocalServiceController\}   
    \* and \{@link LocalServiceBinding\} classes show how to interact with the   
    \* service.   
    \*   
    \* <p>Notice the use of the \{@link NotificationManager\} when interesting things   
    \* happen in the service.    This is generally how background services should   
    \* interact with the user, rather than doing something more disruptive such as   
    \* calling startActivity().   
    \*/   
    public  class LocalService  extends Service \{   
             private NotificationManager mNM;   
      
             /\*\*   
             \* Class for clients to access.    Because we know this service always   
             \* runs in the same process as its clients, we don't need to deal with   
             \* IPC.   
             \*/   
            public class LocalBinder extends Binder \{    
                    LocalService getService() \{    
                            return LocalService.this;   
                    \}   
            \}   
               
            @Override   
             public  void onCreate() \{   
                    mNM = (NotificationManager)getSystemService(NOTIFICATION\_SERVICE);   
      
                     // Display a notification about us starting.    We put an icon in the status bar.   
                    showNotification();   
            \}   
      
            @Override   
             public  int onStartCommand(Intent intent,  int flags,  int startId) \{   
                    Log.i( "LocalService",  "Received start id " + startId +  ": " + intent);   
                     // We want this service to continue running until it is explicitly   
                     // stopped, so return sticky.   
                     return START\_STICKY;   
            \}   
      
            @Override   
             public  void onDestroy() \{   
                     // Cancel the persistent notification.   
                    mNM.cancel(R.string.local\_service\_started);   
      
                     // Tell the user we stopped.   
                    Toast.makeText( this, R.string.local\_service\_stopped, Toast.LENGTH\_SHORT).show();   
            \}   
      
            @Override   
            public IBinder onBind(Intent intent) \{   
                 return mBinder;  
            \}   
      
             // This is the object that receives interactions from clients.    See   
             // RemoteService for a more complete example.   
            private final IBinder mBinder = new LocalBinder();   
      
             /\*\*   
             \* Show a notification while this service is running.   
             \*/   
             private  void showNotification() \{   
                     // In this sample, we'll use the same text for the ticker and the expanded notification   
                    CharSequence text = getText(R.string.local\_service\_started);   
      
                     // Set the icon, scrolling text and timestamp   
                    Notification notification =  new Notification(R.drawable.stat\_sample, text,   
                                    System.currentTimeMillis());   
      
                     // The PendingIntent to launch our activity if the user selects this notification   
                    PendingIntent contentIntent = PendingIntent.getActivity( this, 0,   
                                     new Intent( this, LocalServiceController. class), 0);   
      
                     // Set the info for the views that show in the notification panel.   
                    notification.setLatestEventInfo( this, getText(R.string.local\_service\_label),   
                                                 text, contentIntent);   
      
                     // Send the notification.   
                     // We use a layout id because it is a unique number.    We use it later to cancel.   
                    mNM.notify(R.string.local\_service\_started, notification);   
            \}   
    \}
    
       这里可以发现onBind需要返回一个IBinder对象。也就是说和上一例子LocalService不同的是，
    
    1. 添加了一个public内部类继承Binder，并添加getService方法来返回当前的Service对象；
    
    2. 新建一个IBinder对象——new那个Binder内部类；
    
    3. onBind方法返还那个IBinder对象。
    
      
    
    
    Activity:
    
    /\*\*   
    \* <p>Example of binding and unbinding to the \{@link LocalService\}.   
    \* This demonstrates the implementation of a service which the client will   
    \* bind to, receiving an object through which it can communicate with the service.</p>   
    \*/   
    public  class LocalServiceBinding  extends Activity \{   
             private  boolean mIsBound;   
             private  
            @Override   
             protected  void onCreate(Bundle savedInstanceState) \{   
                     super.onCreate(savedInstanceState);   
      
                    setContentView(R.layout.local\_service\_binding);   
      
                     // Watch for button clicks.   
                    Button button = (Button)findViewById(R.id.bind);   
                    button.setOnClickListener(mBindListener);   
                    button = (Button)findViewById(R.id.unbind);   
                    button.setOnClickListener(mUnbindListener);   
            \}   
      
            private ServiceConnection mConnection = new ServiceConnection() \{   
                    public void onServiceConnected(ComponentName className, IBinder service) \{   
                             // This is called when the connection with the service has been   
                             // established, giving us the service object we can use to   
                             // interact with the service.    Because we have bound to a explicit   
                             // service that we know is running in our own process, we can   
                             // cast its IBinder to a concrete class and directly access it.   
                            mBoundService = ((LocalService.LocalBinder)service).getService();    
                               
                             // Tell the user about this for our demo.   
                            Toast.makeText(LocalServiceBinding. this, R.string.local\_service\_connected,   
                                            Toast.LENGTH\_SHORT).show();   
                    \}   
      
                    public void onServiceDisconnected(ComponentName className) \{    
                             // This is called when the connection with the service has been   
                             // unexpectedly disconnected -- that is, its process crashed.   
                             // Because it is running in our same process, we should never   
                             // see this happen.   
                            mBoundService =  null;   
                            Toast.makeText(LocalServiceBinding. this, R.string.local\_service\_disconnected,   
                                            Toast.LENGTH\_SHORT).show();   
                    \}   
            \};   
      
             private OnClickListener mBindListener =  new OnClickListener() \{   
                     public  void onClick(View v) \{   
                             // Establish a connection with the service.    We use an explicit   
                             // class name because we want a specific service implementation that   
                             // we know will be running in our own process (and thus won't be   
                             // supporting component replacement by other applications).   
                             bindService( new Intent(LocalServiceBinding. this,      
                                            LocalService. class),  mConnection, Context.BIND\_AUTO\_CREATE);   
                            mIsBound =  true;   
                    \}   
            \};   
      
             private OnClickListener mUnbindListener =  new OnClickListener() \{   
                     public  void onClick(View v) \{   
                             if (mIsBound) \{   
                                     // Detach our existing connection.   
                                     unbindService( mConnection);   
                                    mIsBound =  false;   
                            \}   
                    \}   
            \};   
    \}
    
        明显看出这里面添加了一个名为ServiceConnection类，并实现了onServiceConnected(从IBinder获取Service对象)和onServiceDisconnected(set Service to null)。
    
        而bindService和unbindService方法都是操作这个ServiceConnection对象的。
    
      
    
    
    AndroidManifest.xml里添加:
    
    < service  android:name =".app.LocalService"  />   
      
    < activity  android:name =".app.LocalServiceBinding"  android:label ="@string/activity\_local\_service\_binding" >   
          < intent-filter >   
               < action  android:name ="android.intent.action.MAIN"  />   
               < category  android:name ="android.intent.category.SAMPLE\_CODE"  />   
          </ intent-filter >   
    </ activity >
    
    这里没什么特别的，因为service没有需要什么特别的action，所以只是声明service而已，而activity和普通的没差别。  
    
    
      
    
    
    运行时，发现调用次序是这样的：  
    
    
    bindService:
    
    1.LocalService : onCreate  
    2.LocalService : onBind  
    3.Activity: onServiceConnected  
      
    
    
    unbindService: 只是调用onDestroy
    
      
    
    
    可见，onStart是不会被调用的，而onServiceDisconnected没有调用的原因在上面代码的注释有说明。  
    
    
      
    
    
    介绍onStartCommand()需要用到的几个常量 (引自官方文档)
    
    START\_NOT\_STICKY
    
    If the system kills the service after onStartCommand() returns,  do not recreate the service, unless there are pending intents to deliver. This is the safest option to avoid running your service when not necessary and when your application can simply restart any unfinished jobs.
    
      
    
    
    START\_STICKY
    
    If the system kills the service after onStartCommand() returns, recreate the service and call onStartCommand(), but  do not redeliver the last intent. Instead, the system calls onStartCommand() with a null intent, unless there were pending intents to start the service, in which case, those intents are delivered. This is suitable for media players (or similar services) that are not executing commands, but running indefinitely and waiting for a job.
    
      
    
    
    START\_REDELIVER\_INTENT
    
    If the system kills the service after onStartCommand() returns, recreate the service and call onStartCommand() with the last intent that was delivered to the service. Any pending intents are delivered in turn. This is suitable for services that are actively performing a job that should be immediately resumed, such as do wnloading a file.
    
      
    
    
    Running a Service in the Foreground
    
        具体内容查看官方文档，主要是使用 startForeground() 和 stopForeground()方法。
    
      
    
    
    转自：http://android.blog.51cto.com/268543/527314
    
          http://developer.51cto.com/art/201002/183516.htm

[Android]: http://developer.51cto.com/art/201002/182392.htm
[20004_31181_27604_36739]: http://android.blog.51cto.com/attachment/201103/004355525.png