Android学习之Service

最新推荐文章于 2024-07-23 08:44:23 发布

vivianluomin

最新推荐文章于 2024-07-23 08:44:23 发布

阅读量209

点赞数

分类专栏： android 文章标签： android

本文链接：https://blog.csdn.net/qq_36391075/article/details/75314495

版权

android 专栏收录该内容

99 篇文章 2 订阅

订阅专栏

Service是一个应用程序组件，它能够在后台执行一些耗时比较长的操作，并且不提供用户界面。服务能被其他应用程序的组件启动，即使用户切换到另外的应用时还能保持后台运行。此外应用程序组件还能与服务绑定，并与服务进行交互，甚至进行进程间通信（IPC），比如，服务可以处理网络传输，音乐播放，执行文件I/0。或者与content provider进行交互，所有这些都是在后台进行的

服务的两种基本类型：
started:
如果一个应用程序组件通过调用startService（）来启动服务，则该服务就是被started了，一旦被启动，服务就能在后台一直运行下去，即使它启动的组件已经被销毁。通常started的服务执行单一的操作并且不会向调用者返回结果。
bound：如歌一个应用程序组件通过bindService（）绑定到服务，则该服务就是被bound了。bound服务提供了一个客户端/服务端接口，允许组件与服务进行交互，发送请求，获取结果，甚至可以利用进程间通信跨进程执行这些操作。绑定服务的生存期和被绑定应用的应用程序组件一致。多个组件可以同时与一个服务绑定，不过所有的组件解除绑定后，服务也就会被销毁。

服务可以同时用两种方式工作。

服务运行于宿主进程的主线程中——不创建自己的线程并且不是运行在单独的进程中（除非你明确指定）。这意味着，如果你的服务要执行一些很耗CPU的工作或者阻塞的操作（比如播放MP3或网络操作），你应该在服务中创建一个新的线程来执行这些工作。利用单独的线程，将减少你的activity发生应用程序停止响应（ANR）错误的风险

概述

为了创建一个服务，必须新建一个Service的子类
onStartCommand（）：当其他组件，通过调用startService（）来请求started方法的服务的时候，系统会调用笨方法。一旦本方法执行，服务就被启动并在后台一直运行下去。
onBind（）：当其他自检通过bindService（）绑定服务的时候。系统会调用笨方法。在本方法的实现代码中，你必须返回IBinder来提供一个接口，客户端用它来和服务进行通信。
onCreate（）：当服务第一次被创建的时候，系统会调用笨方法，用于执行一次性的配置工作。
onDestroy（）当服务用不上了并要被销毁的时候，系统会调用本方法。服务应该实现本方法进行资源的清理工作。

如果组件通过调用startService()（这会导致onStartCommand()的调用）启动了服务，那么服务将一直保持运行，直至自行用stopSelf()终止或由其它组件调用stopService()来终止它。

如果组件调用bindService()来创建服务（那onStartCommand()就不会被调用），则服务的生存期就与被绑定的组件一致。一旦所有客户端都对服务解除了绑定，系统就会销毁该服务。

与activity一样，服务可以定义intent过滤器，使得其它组件能用隐式intent来调用服务。通过声明intent过滤器，任何安装在用户设备上的应用程序组件都有能力来启动你的服务，只要你的服务所声明的intent过滤器与其它应用程序传递给startService()的intent相匹配即可。

如果你想让服务只能内部使用（其它应用程序无法调用），那么就不必（也不应该）提供任何intent过滤器。如果不存在任何intent过滤器，那你就必须用精确指定服务类名的intent来启动服务。

创建一个started服务：

started服务是指其他组件通过调用startedService（）来启动的服务，这会引发对该服务onStartCommand（）方法的调用，并传入一个给出了服务和服务所需数据的Intent对象，服务将在onStartCommand（）方法中接受该Intent对象。

扩展两个类来创建started服务：
Service
这是所有服务的基类。如果你要扩展该类，则很重要的一点是：请在其中创建一个新的线程来完成所有的服务工作。因为服务默认是使用应用程序的主线程的，这会降低应用程序中activity的运行性能。

IntentService
这是Service类的子类，它使用了工作（worker）线程来处理所有的启动请求，每次请求都会启动一个线程。如果服务不需要同时处理多个请求的话，这是最佳的选择。所有你要做的工作就是实现onHandleIntent()即可，它会接收每个启动请求的intent，然后就可在后台完成工作。

IntentService：

执行步骤：
创建一个缺省的工作（work）线程，它独立于应用程序主线程来执行所有发送到onStartCommand（）的intent。
创建一个工作队列，每次向你的onHandleIntent（）传入一个intent，这样就不用担心多线程
在处理完所有请求后，终止服务，因此不会调用stopSelf（）。
提供缺省的onBind实现代码，返回null；
提供缺省的onStartCommand（）实现代码，它把intent送入工作队列，销毁会再传给onHandleIntent（）

例子：

public class HelloIntentService extends IntentService {

  /** 
   * 构造方法是必需的，必须用工作线程名称作为参数
   * 调用父类的[http://developer.android.com/reference/android/app/IntentService.html#IntentService(java.lang.String) IntentService(String)]构造方法。
   */
  public HelloIntentService() {
      super("HelloIntentService");
  }

  /**
   * IntentService从缺省的工作线程中调用本方法，并用启动服务的intent作为参数。 
   * 本方法返回后，IntentService将适时终止这个服务。
   */
  @Override
  protected void onHandleIntent(Intent intent) {
      // 通常我们会在这里执行一些工作，比如下载文件。
      // 作为例子，我们只是睡5秒钟。
      long endTime = System.currentTimeMillis() + 5*1000;
      while (System.currentTimeMillis() < endTime) {
          synchronized (this) {
              try {
                  wait(endTime - System.currentTimeMillis());
              } catch (Exception e) {
              }
          }
      }
  }
  @Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
    return super.onStartCommand(intent,flags,startId);
}
}

IntentService的源码分析：

private final class ServiceHandler extends Handler {  
    public ServiceHandler(Looper looper) {  
        super(looper);  
    }  

    @Override  
    public void handleMessage(Message msg) {  
        onHandleIntent((Intent)msg.obj);  
        stopSelf(msg.arg1);  
    }  
}  

/** 
 * Creates an IntentService.  Invoked by your subclass's constructor. 
 * 
 * @param name Used to name the worker thread, important only for debugging. 
 */  
public IntentService(String name) {  
    super();  
    mName = name;  
}  

/** 
 * Sets intent redelivery preferences.  Usually called from the constructor 
 * with your preferred semantics. 
 * 
 * <p>If enabled is true, 
 * {@link #onStartCommand(Intent, int, int)} will return 
 * {@link Service#START_REDELIVER_INTENT}, so if this process dies before 
 * {@link #onHandleIntent(Intent)} returns, the process will be restarted 
 * and the intent redelivered.  If multiple Intents have been sent, only 
 * the most recent one is guaranteed to be redelivered. 
 * 
 * <p>If enabled is false (the default), 
 * {@link #onStartCommand(Intent, int, int)} will return 
 * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent 
 * dies along with it. 
 */  
public void setIntentRedelivery(boolean enabled) {  
    mRedelivery = enabled;  
}  

@Override  
public void onCreate() {  
    // TODO: It would be nice to have an option to hold a partial wakelock  
    // during processing, and to have a static startService(Context, Intent)  
    // method that would launch the service & hand off a wakelock.  

    super.onCreate();  
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");  
    thread.start();  

    mServiceLooper = thread.getLooper();  
    mServiceHandler = new ServiceHandler(mServiceLooper);  
}  

@Override  
public void onStart(Intent intent, int startId) {  
    Message msg = mServiceHandler.obtainMessage();  
    msg.arg1 = startId;  
    msg.obj = intent;  
    mServiceHandler.sendMessage(msg);  
}

在这里我们可以清楚的看到其实IntentService在执行onCreate的方法的时候，其实开了一个线程HandlerThread,并获得了当前线程队列管理的looper，并且在onStart的时候，把消息置入了消息队列
在消息被handler接受并且回调的时候，执行了onHandlerIntent方法，该方法的实现是子类去做的。

结论：

IntentService是通过Handler looper message的方式实现了一个多线程的操作，同时耗时操作也可以被这个线程管理和执行，同时不会产生ANR的情况。

Service类：

利用IntentService来实现一个started服务非常简单。不过，假如你的服务需要多线程运行（而不是通过一个工作队列来处理启动请求），那你可以扩展Service类来完成每个intent的处理。

对照例子：

public class HelloService extends Service {
  private Looper mServiceLooper;
  private ServiceHandler mServiceHandler;

  // 处理从线程接收的消息
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          // 通常我们在这里执行一些工作，比如下载文件。
          // 作为例子，我们只是睡个5秒钟。
          long endTime = System.currentTimeMillis() + 5*1000;
          while (System.currentTimeMillis() < endTime) {
              synchronized (this) {
                  try {
                      wait(endTime - System.currentTimeMillis());
                  } catch (Exception e) {
                  }
              }
          }
          // 根据startId终止服务，这样我们就不会在处理其它工作的过程中再来终止服务
          stopSelf(msg.arg1);
      }
  }

  @Override
  public void onCreate() {
    // 启动运行服务的线程。
    // 请记住我们要创建一个单独的线程，因为服务通常运行于进程的主线程中，可我们不想阻塞主线程。
    // 我们还要赋予它后台运行的优先级，以便计算密集的工作不会干扰我们的UI。
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();

    // 获得HandlerThread的Looper队列并用于Handler
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();

      // 对于每一个启动请求，都发送一个消息来启动一个处理
      // 同时传入启动ID，以便任务完成后我们知道该终止哪一个请求。
      Message msg = mServiceHandler.obtainMessage();
      msg.arg1 = startId;
      mServiceHandler.sendMessage(msg);

      // 如果我们被杀死了，那从这里返回之后被重启
      return START_STICKY;
  }

  @Override
  public IBinder onBind(Intent intent) {
      // 我们不支持绑定，所以返回null
      return null;
  }

  @Override
  public void onDestroy() {
    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show(); 
  }
}

请注意onStartCommand()方法必须返回一个整数。这个整数是描述系统在杀死服务之后应该如何继续运行（上一节中缺省的 IntentService 实现代码会替你处理这一点，当然那样你就无法修改这个处理过程）。onStartCommand()的返回值必须是以下常量之一：
START_NOT_STICKY
如果系统在onStartCommand()返回后杀死了服务，则不会重建服务了，除非还存在未发送的intent。当服务不再是必需的，并且应用程序能够简单地重启那些未完成的工作时，这是避免服务运行的最安全的选项。
START_STICKY
如果系统在onStartCommand()返回后杀死了服务，则将重建服务并调用onStartCommand()，但不会再次送入上一个intent，而是用null intent来调用onStartCommand() 。除非还有启动服务的intent未发送完，那么这些剩下的intent会继续发送。这适用于媒体播放器（或类似服务），它们不执行命令，但需要一直运行并随时待命。
START_REDELIVER_INTENT
如果系统在onStartCommand()返回后杀死了服务，则将重建服务并用上一个已送过的intent调用onStartCommand()。任何未发送完的intent也都会依次送入。这适用于那些需要立即恢复工作的活跃服务，比如下载文件。

启动一个服务：

Intent intent = new Intent(this, HelloService.class);
startService(intent);

startService()方法会立即返回，Android系统会去调用服务的onStartCommand() 方法。如果服务还未运行，系统会首先调用onCreate()，然后再去调用onStartCommand() 。
如果服务不同时支持绑定，那么通过startService（）传入的intent将是应用程序组件与服务进行交互的唯一途径。如果期望服务能返回结果，那么启动服务的客户端可以创建一个PendingIntent来获得一个广播broadcast（利用getBroadcast（）），并把它放入启动服务的Intent并传到服务中，然后服务就会用这个broadcast来传递消息。

终止一个服务：

一个started服务必须自行管理生命周期。也就是说，系统不会终止或销毁这类服务，除非必须恢复系统内存并且服务返回后一直维持运行。因此，服务必须通过调用stopSelf()自行终止，或者其它组件可通过调用stopService()来终止它。

用stopSelf()或stopService()的终止请求一旦发出，系统就会尽快销毁服务。

不过，如果你的服务要同时处理多个onStartCommand()请求，那在处理启动请求的过程中，你就不应该去终止服务，因为你可能接收到了一个新的启动请求（在第一个请求处理完毕后终止服务将停止第二个请求的处理。为了避免这个问题，你可以用stopSelf(int)来确保终止服务的请求总是根据最近一次的启动请求来完成。也就是说，当你调用stopSelf(int) 时，你把启动请求ID（发送给onStartCommand()的startId）传给了对应的终止请求。这样，如果服务在你可以调用stopSelf(int)时接收到了新的启动请求，则ID将会不一样，服务将不会被终止。

创建一个bound服务：

bound服务是指允许被应用程序组件绑定的服务，通过调用bindService()可以完成绑定，用于创建一个长期存在的连接（并且一般不再允许组件通过调用startService()来start服务。

当应用程序中的activity或其它组件需要与服务进行交互，或者应用程序的某些功能需要暴露给其它应用程序时，你应该创建一个bound服务，并通过进程间通信（IPC）来完成。

要创建一个bound服务，你必须实现onBind()回调方法，并返回一个IBinder对象，此对象定义了与服务进行通信的接口。然后，其它应用程序组件可以调用bindService()来获得接口并调用服务中的方法。服务只在为绑定的应用程序组件工作时才会存活，因此，只要没有组件绑定到服务，系统就会自动销毁服务（你不需要像started服务中那样通过onStartCommand()来终止一个bound服务）。

要创建一个bound服务，首先必须定义好接口，用于指明客户端如何与服务进行通信。这个客户端与服务之间的接口必须是一个IBinder对象的实现，并且你的服务必须在onBind()回调方法中返回这个对象。一旦客户端接收到这个IBinder，它就可以通过这个接口来与服务进行交互。

同一个服务可以被多个客户端绑定。当客户端完成交互时，会调用unbindService()来解除绑定。一旦不存在客户端与服务绑定时，系统就会销毁该服务。

在前台运行服务
前台服务是指那些经常会被用户关注的服务，因此内存过低时它不会成为被杀的对象。前台服务必须提供一个状态栏痛，并会置于“正在进行的”（Ongoing）组下。这意味着只有在服务被终止或者从前台移除之后，此通知才能被解除。
要把你的服务请求为前台运行，可以调用startForeground（）方法。

Notification notification = new Notification(R.drawable.icon, getText(R.string.ticker_text),
        System.currentTimeMillis());
Intent notificationIntent = new Intent(this, ExampleActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
notification.setLatestEventInfo(this, getText(R.string.notification_title),
        getText(R.string.notification_message), pendingIntent);
startForeground(ONGOING_NOTIFICATION, notification);

要从前台移除服务，请调用stopForeground()方法，这个方法接受个布尔参数，表示是否同时移除状态栏通知。此方法不会终止服务。不过，如果服务在前台运行时被你终止了，那么通知也会同时被移除。

当绑定到一个已经用startService()启动的服务上。例如，一个后台音乐服务可以通过调用startService()来启动，传入一个指明所需播放音乐的 Intent。之后，用户也许需要用播放器进行一些控制，或者需要查看当前歌曲的信息，这时一个activity可以通过调用bindService()与此服务绑定。在类似这种情况下，stopService()或stopSelf()不会真的终止服务，除非所有的客户端都解除了绑定。

服务的生命周期

public class ExampleService extends Service {
    int mStartMode;       // 标识服务被杀死后的处理方式
    IBinder mBinder;      // 用于客户端绑定的接口
    boolean mAllowRebind; // 标识是否使用onRebind

    @Override
    public void onCreate() {
        // 服务正被创建
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 服务正在启动，由startService()调用引发
        return mStartMode;
    }
    @Override
    public IBinder onBind(Intent intent) {
        // 客户端用bindService()绑定服务
        return mBinder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        // 所有的客户端都用unbindService()解除了绑定
        return mAllowRebind;
    }
    @Override
    public void onRebind(Intent intent) {
        // 某客户端正用bindService()绑定到服务,
        // 而onUnbind()已经被调用过了
    }
    @Override
    public void onDestroy() {
        // 服务用不上了，将被销毁
    }

vivianluomin

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android学习之Service

Service是一个应用程序组件，它能够在后台执行一些耗时比较长的操作，并且不提供用户界面。服务能被其他应用程序的组件启动，即使用户切换到另外的应用时还能保持后台运行。此外应用程序组件还能与服务绑定，并与服务进行交互，甚至进行进程间通信（IPC），比如，服务可以处理网络传输，音乐播放，执行文件I/0。或者与content provider进行交互，所有这些都是在后台进行的服务的两种基本类型： st
复制链接

扫一扫

专栏目录