Android四大组件之- Service概述

Service 是一个可以在后台执行长时间运行操作而不使用用户界面的应用组件。服务可由其他应用组件启动,而且即使用户切换到其他应用,服务仍将在后台继续运行。 此外,组件可以绑定到服务,以与之进行交互,甚至是执行进程间通信 (IPC)。 例如,服务可以处理网络事务、播放音乐,执行文件 I/O 或与内容提供程序交互,而所有这一切均可在后台进行。

服务基本上分为两种形式:

启动

当应用组件(如 Activity)通过调用 startService()
启动服务时,服务即处于“启动”状态。一旦启动,服务即可在后台无限期运行,即使启动服务的组件已被销毁也不受影响。已启动的服务通常是执行单一操作,而且不会将结果返回给调用方。例如,它可能通过网络下载或上传文件。 操作完成后,服务会自行停止运行。

绑定

当应用组件通过调用 bindService() 绑定到服务时,服务即处于“绑定”状态。绑定服务提供了一个客户端-服务器接口,允许组件与服务进行交互、发送请求、获取结果,甚至是利用进程间通信(IPC) 跨进程执行这些操作。 仅当与另一个应用组件绑定时,绑定服务才会运行。多个组件可以同时绑定到该服务,但全部取消绑定后,该服务即会被销毁。

虽然本文档是分开概括讨论这两种服务,但是您的服务可以同时以这两种方式运行,也就是说,它既可以是启动服务(以无限期运行),也允许绑定。问题只是在于您是否实现了一组回调方法:onStartCommand()(允许组件启动服务)和 onBind()(允许绑定服务)。

无论应用是处于启动状态还是绑定状态,抑或处于启动并且绑定状态,任何应用组件均可像使用活动那样通过调用 Intent 来使用服务(即使此服务来自另一应用)。 不过,您可以通过清单文件将服务声明为私有服务,并阻止其他应用访问。

应重写的最重要的回调方法包括:
1、onStartCommand()

启动服务startService() -> 重写 onStartCommand() 一旦执行此方法,服务即会启动并可在后台无限期运行。 如果已实现此方法,则在服务工作完成后,需要通过调用 stopSelf()或stopService()来停止服务。(如果您只想提供绑定,则无需实现此方法。)

2、onBind()

绑定服务 bindService(),系统将调用此方法onBind()。在此方法的实现中,必须通过返回IBinder提供一个接口,供客户端用来与服务进行通信。请务必实现此方法,但如果并不希望允许绑定,则应返回 null。

3、onCreate()

首次创建服务时,系统将调用此方法来执行一次性设置程序(在调用 onStartCommand() 或
onBind()之前)。如果服务已在运行,则不会调用此方法。

4、onDestroy()

当服务不再使用且将被销毁时,系统将调用此方法。服务应该实现此方法来清理所有资源,如线程、注册的侦听器、接收器等。 这是服务接收的最后一个调用。

如果组件通过调用 startService()启动服务(这会导致对 onStartCommand()的调用),则服务将一直运行,直到服务使用 stopSelf()自行停止运行,或由其他组件通过调用 stopService()停止它为止。

如果组件是通过调用 bindService()来创建服务(且未调用 onStartCommand()),则服务只会在该组件与其绑定时运行。一旦该服务与所有客户端之间的绑定全部取消,系统便会销毁它。

为了确保应用的安全性,请始终使用显式 Intent 启动或绑定 Service ,且不要为服务声明 Intent 过滤器。

创建启动服务

从传统上讲,可以扩展Service , IntentService两个类

  1. Service
    这是适用于所有服务的基类。扩展此类时,必须创建一个用于执行所有服务工作的新线程,因为默认情况下,服务将使用应用的主线程,这会降低应用正在运行的所有 Activity 的性能。
    扩展 Service类来创建启动服务 :

该基类包含更多代码,但如需同时处理多个启动请求,则更适合使用该基类;
使用 IntentService显著简化了启动服务的实现。但是,若要求服务执行多线程(而不是通过工作队列处理启动请求),则可扩展Service类来处理每个 Intent。为了便于比较,以下提供了 Service 类实现的代码示例,该类执行的工作与使用IntentService的示例完全相同。也就是说,对于每个启动请求,它均使用工作线程执行作业,且每次仅处理一个请求。

以下是使用 Service类的代码示例:

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) {
            long endTime = System.currentTimeMillis() + 5 * 1000;
            while (System.currentTimeMillis() < endTime) {
                synchronized (this) {
                    try {
                        wait(endTime - System.currentTimeMillis());
                    } catch (Exception e) {
                    }
                }
            }
            stopSelf(msg.arg1);
        }
    }

    @Override
    public void onCreate() {
        HandlerThread thread = new HandlerThread("ServiceStartArguments",
                Process.THREAD_PRIORITY_BACKGROUND);
        thread.start();
        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();

        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        mServiceHandler.sendMessage(msg);
        return START_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

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

2. IntentService
这是 Service的子类,它使用工作线程逐一处理所有启动请求。如果您不要求服务同时处理多个请求,这是最好的选择。 您只需实现 onHandleIntent()方法即可,该方法会接收每个启动请求的 Intent,使您能够执行后台工作。
扩展IntentService创建启动服务,执行以下操作:
创建默认的工作线程,用于在应用的主线程外执行传递给 onStartCommand()的所有 Intent。
创建工作队列,用于将一个 Intent 逐一传递给 onHandleIntent()实现,这样您就永远不必担心多线程问题。
在处理完所有启动请求后停止服务,因此您永远不必调用 stopSelf()。
提供 onBind()的默认实现(返回 null)。
提供 onStartCommand()的默认实现,可将 Intent 依次发送到工作队列和 onHandleIntent()实现。
综上所述 :
只需实现 onHandleIntent()来完成客户端提供的工作即可。(不过,您还需要为服务提供小型构造函数。)
以下是 IntentService的实现示例:

public class HelloIntentService extends IntentService {
      public HelloIntentService() {
          super("HelloIntentService");
      }
      @Override
      protected void onHandleIntent(Intent intent) {
          long endTime = System.currentTimeMillis() + 5 * 1000;
          while (System.currentTimeMillis() < endTime) {
              synchronized (this) {
                  try {
                      wait(endTime - System.currentTimeMillis());
                  } catch (Exception e) {
                  }
              }
          }
      }
}

– 您只需要一个构造函数和一个 onHandleIntent()实现即可。
如果您决定还重写其他回调方法(如 onCreate()、onStartCommand()或 onDestroy()),请确保调用超类实现,以便 IntentService能够妥善处理工作线程的生命周期。
例如,onStartCommand()必须返回默认实现(即,如何将 Intent 传递给 onHandleIntent()):

@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);
}

除 onHandleIntent()之外,您无需从中调用超类的唯一方法就是 onBind()(仅当服务允许绑定时,才需要实现该方法)。

启动服务

可以通过将 Intent,从 Activity 或其他应用组件启动服务。Android 系统调用服务的 onStartCommand()
方法,并向其传递 Intent。(切勿直接调用onStartCommand()。)
例如,Activity 可以结合使用显式 Intent 与 startService()
,启动上文中的示例服务 (HelloSevice):

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

startService()方法将立即返回,且 Android 系统调用服务的 onStartCommand()方法。如果服务尚未运行,则系统会先调用 onCreate(),然后再调用 onStartCommand()。

如果服务亦未提供绑定,则使用 startService()传递的 Intent 是应用组件与服务之间唯一的通信模式。但是,如果您希望服务返回结果,则启动服务的客户端可以为广播创建一个 PendingIntent(使用getBroadcast()),并通过启动服务的 Intent传递给服务。然后,服务就可以使用广播传递结果。

多个服务启动请求会导致多次对服务的 onStartCommand()进行相应的调用。但是,要停止服务,只需一个服务停止请求(使用 stopSelf() 或 stopService())即可。

停止服务
启动服务必须管理自己的生命周期。也就是说,除非系统必须回收内存资源,否则系统不会停止或销毁服务,而且服务在 onStartCommand()返回后会继续运行。因此,服务必须通过调用 stopSelf()
自行停止运行,或者由另一个组件通过调用 stopService()来停止它。

一旦请求使用 stopSelf()或 stopService()停止服务,系统就会尽快销毁服务。

但是,如果服务同时处理多个 onStartCommand()请求,则您不应在处理完一个启动请求之后停止服务,因为您可能已经收到了新的启动请求(在第一个请求结束时停止服务会终止第二个请求)。为了避免这一问题,您可以使用 stopSelf(int)确保服务停止请求始终基于最近的启动请求。也就说,在调用 stopSelf(int)时,传递与停止请求的 ID 对应的启动请求的 ID(传递给 onStartCommand()的 startId) 。然后,如果在您能够调用stopSelf(int)之前服务收到了新的启动请求, ID 就不匹配,服务也就不会停止。

注意:为了避免浪费系统资源和消耗电池电量,应用必须在工作完成之后停止其服务。 如有必要,其他组件可以通过调用 stopService()来停止服务。即使为服务启用了绑定,一旦服务收到对 onStartCommand()的调用,您始终仍须亲自停止服务。

创建绑定服务
绑定服务允许应用组件通过调用 bindService()与其绑定,以便创建长期连接(通常不允许组件通过调用startService()来启动它)。

如需与 Activity 和其他应用组件中的服务进行交互,或者需要通过进程间通信 (IPC) 向其他应用公开某些应用功能,则应创建绑定服务。

要创建绑定服务,必须实现 onBind()回调方法以返回 IBinder,用于定义与服务通信的接口。然后,其他应用组件可以调用 bindService()来检索该接口,并开始对服务调用方法。服务只用于与其绑定的应用组件,因此如果没有组件绑定到服务,则系统会销毁服务(您不必按通过 onStartCommand()
启动的服务那样来停止绑定服务)。

要创建绑定服务,首先必须定义指定客户端如何与服务通信的接口。 服务与客户端之间的这个接口必须是IBinder的实现,并且服务必须从 onBind()回调方法返回它。一旦客户端收到 IBinder
,即可开始通过该接口与服务进行交互。

多个客户端可以同时绑定到服务。客户端完成与服务的交互后,会调用 unbindService()
取消绑定。一旦没有客户端绑定到该服务,系统就会销毁它。

有多种方法实现绑定服务,其实现比启动服务更为复杂,因此绑定服务将在有关绑定服务的单独文档中专门讨论。

向用户发送通知
一旦运行起来,服务即可使用 Toast 通知或状态栏通知来通知用户所发生的事件。

Toast 通知是指出现在当前窗口的表面、片刻随即消失不见的消息,而状态栏通知则在状态栏提供内含消息的图标,用户可以选择该图标来采取操作(例如启动 Activity)。

通常,当某些后台工作已经完成(例如文件下载完成)且用户现在可以对其进行操作时,状态栏通知是最佳方法。 当用户从展开视图中选定通知时,通知即可启动 Activity(例如查看已下载的文件)。

如需了解详细信息,请参阅 Toast 通知或状态栏通知开发者指南。

在前台运行服务
前台服务被认为是用户主动意识到的一种服务,因此在内存不足时,系统也不会考虑将其终止。 前台服务必须为状态栏提供通知,状态栏位于“正在进行”标题下方,这意味着除非服务停止或从前台删除,否则不能清除通知。

例如,应该将从服务播放音乐的音乐播放器设置为在前台运行,这是因为用户明确意识到其操作。 状态栏中的通知可能表示正在播放的歌曲,并允许用户启动 Activity 来与音乐播放器进行交互。

要请求让服务运行于前台,请调用 startForeground()。此方法取两个参数:唯一标识通知的整型数和状态栏的 Notification。例如:

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_ID, notification);

注意:提供给 startForeground()的整型 ID 不得为 0

要从前台删除服务,请调用 stopForeground()。此方法取一个布尔值,指示是否也删除状态栏通知。 此方法绝对不会停止服务。
但是,如果您在服务正在前台运行时将其停止,则通知也会被删除。
如需了解有关通知的详细信息,请参阅创建状态栏通知。

管理服务生命周期

服务的生命周期比 Activity 的生命周期要简单得多。但是,密切关注如何创建和销毁服务反而更加重要,因为服务可以在用户没有意识到的情况下运行于后台。

服务生命周期(从创建到销毁)可以遵循两条不同的路径:

1、启动服务
该服务在其他组件调用 startService()时创建,然后无限期运行,且必须通过调用 stopSelf()来自行停止运行。此外,其他组件也可以通过调用 stopService()来停止服务。服务停止后,系统会将其销毁。
2、绑定服务
该服务在另一个组件(客户端)调用 bindService()时创建。然后,客户端通过 IBinder接口与服务进行通信。客户端可以通过调用 unbindService()关闭连接。多个客户端可以绑定到相同服务,而且当所有绑定全部取消后,系统即会销毁该服务。 (服务不必自行停止运行。)
这两条路径并非完全独立。也就是说,您可以绑定到已经使用 startService()启动的服务。例如,可以通过使用 Intent(标识要播放的音乐)调用 startService()来启动后台音乐服务。随后,可能在用户需要稍加控制播放器或获取有关当前播放歌曲的信息时,Activity 可以通过调用 bindService()绑定到服务。在这种情况下,除非所有客户端均取消绑定,否则 stopService() 或 stopSelf()不会真正停止服务。

实现生命周期回调

与 Activity 类似,服务也拥有生命周期回调方法,您可以实现这些方法来监控服务状态的变化并适时执行工作。 以下框架服务展示了每种生命周期方法:

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 生命周期回调方法不同,您不需要调用这些回调方法的超类实现。
这里写图片描述

服务生命周期左图显示了使用 startService()所创建的服务的生命周期,右图显示了使用 bindService()所创建的服务的生命周期。

通过实现这些方法,您可以监控服务生命周期的两个嵌套循环:

服务的 整个生命周期 从调用 onCreate()开始起,到 onDestroy()返回时结束。与 Activity 类似,服务也在 onCreate()中完成初始设置,并在 onDestroy()中释放所有剩余资源。例如,音乐播放服务可以在onCreate()中创建用于播放音乐的线程,然后在 onDestroy()中停止该线程。无论服务是通过 startService()还是 bindService()创建,都会为所有服务调用 onCreate()和onDestroy()方法。

服务的 有效生命周期 从调用 onStartCommand()或 onBind()方法开始。每种方法均有 Intent对象,该对象分别传递到 startService()或 bindService()。对于启动服务,有效生命周期与整个生命周期同时结束(即便是在 onStartCommand()返回之后,服务仍然处于活动状态)。对于绑定服务,有效生命周期在 onUnbind()返回时结束

注:尽管启动服务是通过调用 stopSelf()或 stopService()来停止,但是该服务并无相应的回调(没有onStop()回调)。因此,除非服务绑定到客户端,否则在服务停止时,系统会将其销毁—onDestroy()是接收到的唯一回调。
上图说明了服务的典型回调方法。尽管该图分开介绍通过 startService()创建的服务和通过bindService()创建的服务,但是请记住,不管启动方式如何,任何服务均有可能允许客户端与其绑定。因此,最初用 onStartCommand()(通过客户端调用 startService())启动的服务仍可接收对 onBind()的调用(当客户端调用 bindService()时)。

本页内容版权归属为原作者,如有侵犯您的权益,请通知我们删除。

RecyclerView的使用与深入分析 - 2016-06-03 17:06:20

转载请注明出处: http://blog.csdn.net/evan_man/article/details/51570466      最近一直在捣鼓RecyclerView,今天闲来无事就把之前收集到的资料和使用过程中的体会整理一下,写了如下这篇博客。博客的结构跟之前的博客结构类似,首先简单交代背景,随后给出一个简单使用的实例,最终根据前面遇到的一些问题,走进底层看看源码如何实现。不过我们的重点是分析RecyclerView的ViewHolder资源回收策略。顺便吐槽一句一九八网络科技V客学院(htt

安卓Zygote详解 - 2016-06-03 17:06:17

一、Zygote, 意为“受精卵” ,Android系统中几乎所有的应用进程都是由Zygote进程孵化出来的,Java环境也是由Zygote创建起来的,它建立了我们app运行所需要的环境,是app的祖先,因此,分析它的启动以及内部逻辑显得非常有必要。     *Android系统是基于Linux内核的,而在Linux系统中,所有的进程都是init进程的子孙进程,也就是说,所有的进程都是直接或者间接地由init进程fork出来的。Zygote进程也不例外,它是在系统启动的过程,由init进程创建的。在系统启
subversion 服务端和客户端安装 VisualSVN-Server-2.7.3.msi TortoiseSVN-1.6.6.17493-win32-svn-1.6.6.msi TortoiseSVN 基本操作和冲突演示 eclipse 插件演示 eclipse_svn_site-1.6.5.zip 使用 svn 案例演示 某研发团队 2011 年初开发了一款名为 Apollo 的信息系统,目前已发布 v1.0 版本。此项目初期已有部分基础代码,研发团队再此基础代码上经过 3 个月的努力发布了一个功
上一篇,我们基本知道了EventBus的使用步骤,接下来先简单研究一下其中的源码。在分析源码之前,我们先回顾一下Java反射的知识点: JAVA反射机制 基本定义: JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 Sun为提供的关于反射机制中的类: java.lang.Class; java.lang.reflect.Constructor; j

套接字—Socket - 2016-06-03 17:06:03

网络编程就不得不提大名鼎鼎的套接字—Socket 一,什么是Socket 网络上的两个程序通过一个双向的通信连接实现数据的交换,这个连接的一端称为一个Socket。Socket的英文原意是“插座”,通常称之为套接字,来描述IP地址和端口,是一个通信链的句柄,用来实现不同虚拟机或者计算机之间的通信。 在Internet上的主机一般运行了多个服务软件,同时提供几种服务。每种服务都打开一个Socket,并绑定到一个端口上,与不同客户端的不同服务对应着不同的Socket,这样实现了与多个服务器进行不同服务的功能,

Android AsyncTask 封装初步一 - 2016-06-03 17:06:03

AsyncTask基本使用 先从最熟悉的Task使用开始说起,给出LastDaysTask作为实例如下 @SuppressLint ( "NewApi" ) private class LastDaysTask extends AsyncTask Void , Integer , Boolean { @Override protected void onPreExecute () { //TODO UI线程或者主线程 } @Override protected Boolean doInBackground
之前记录过OC版实现3D Touch功能的小小演示,最近无事整整swift,也弄个swift版的3D Touoch。。。 上代码。 一、3D Touch重按主屏icon出现快捷标签有两种添加方式: 1.静态添加,在工程中的 info.plist 文件中添加,这种方式添加的标签安装后就能显示 2.动态添加,通过代码动态添加快速入口。这种方式添加的标签,必须先运行一次App才会出现。 func application(application: UIApplication, didFinishLaunching
1、View是什么 View是Android所有控件的基类,简单到TextView、Button,复杂到RelativeLayout,LinearLayout,其共同基类都是View。 所以,View可以理解为控件的抽象,也是一个控件。 除此之外,还有ViewGroup,字面意义上,它表示控件组,内部可以包含许多个控件。 ViewGroup也继承自View,这意味着,一个View的可以是单个控件,也可以是多个控件组成的一组控件,这就形成了View树。 下面这个图很好地体现了View的继承关系 2、View
随着移动技术的深入发展,各种炫酷效果的更新,在我们追求UI与UE的同时一个不如忽视的问题逐渐暴露出来,那就是apk文件越来越大,可能有的童鞋会说现在都是wifi环境,apk文件增大几M不是什么大不了的问题,这其实也是有一定道理的,但是作为开发人员的我们这绝不是我们认为可以忽略这个问题的理由。优化Apk大小也是优化我们App体验的一个重要方面,虽然可能它不是那么的重要。 那么到底是那些原因让我们的Apk文件变得越来越大呢? 多屏幕是适配问题,移动设备的多样化导致了一个app需要N钟不同尺寸的设置,从而增加了

浅谈android中的异步加载一 - 2016-06-03 14:06:55

1、为什么需要异步加载。     因为我们都知道在Android中的是单线程模型,不允许其他的子线程来更新UI,只允许UI线程(主线程更新UI),否则会多个线程都去更新UI会造成UI的一个混乱有些耗时的操纵(例如网络请求等),如果直接放到主线程中去请求的话则会造成主线程阻塞,而我们系统有规定的响应时间,当响应的时间超过了了阻塞的时间就会造成"Application No Response",也就是我们熟知的ANR错误解决上述问题的时候:我们一般使用的是线程或者线程池+Handler机制如果线程拿到一个数据需