Android 之 四大组件、六大布局、五大存储

Android 之四大组件、六大布局、五大存储：https://blog.csdn.net/shenggaofei/article/details/52450668

Android 四大组件、五大存储、六大布局：https://blog.csdn.net/xiankog/article/details/81702119

Android四大基本组件介绍与生命周期：https://www.cnblogs.com/bravestarrhu/archive/2012/05/02/2479461.html

转自：Android开发入门与实践

一、Android 四大组件详解

Android 四大核心组件指的是 Activity、Service、Content Provider、BroadCast Receiver，核心组件都是由 Android 系统进行管理和维护的，一般都要在清单文件中进行注册或者在代码中动态注册。

1. 活动(activity)：用于表现功能；
2. 服务(service)：后台运行服务，不提供界面呈现；
3. 广播接受者(Broadcast Receive)：用于接收广播；
4. 内容提供者(Content Provider)：支持多个应用中存储和读取数据。

1.1 activity

1、概念：

在 android 中，Activity 相当于一个页面，可以在 Activity 中添加 Button、CheckBox 等控件，一个 android 程序有多个 Activity 组成。

• (1)一个 Activity 通常就是一个单独的屏幕(窗口)。
• (2)Activity 之间通过 Intent 进行通信。
• (3)Android 应用中每一个 Activity 都必须要在 AndroidManifest.xml 配置文件中声明，否则系统将不识别也不执行该Activity。在 android stdio会自动生成，但 eclipse 需要自己手动添加

定义与作用： Activity 的中文意思是 活动，代表手机屏幕的一屏，或是平板电脑中的一个窗口，提供了和用户交互的可视化界面。一个活动开始，代表 Activity 组件启动，活动 结束，代表一个 Activity 的生命周期结束。一个 Android 应用必须通过 Activity 来 运行 和 启动，Activity 的生命周期交给系统统一管理。Activity 是用于处理 UI 相关业务的，比如加载界面、监听用户操作事件。

Activity 之间通过 Intent 进行通信；直接通过 Bundle 对象来传递

在Intent 的描述结构中，有两个最重要的部分：动作和动作对应的数据。

典型的动作类型有：MAIN(activity 的门户)、VIEW、PICK、EDIT 等。而动作对应的数据则以 URI 的形式进行表示。

例如：要查看一个人的联系方式，你需要创建一个动作类型为VIEW 的intent，以及一个表示这个人的URI。

与之有关系的一个类叫 IntentFilter。相对于 intent 是一个有效的做某事的请求，一个 intentfilter 则用于描述一个 activity(或者IntentReceiver)能够操作哪些 intent。一个 activity 如果要显示一个人的联系方式时，需要声明一个 IntentFilter，这个IntentFilter 要知道怎么去处理 VIEW 动作和表示一个人的 URI。IntentFilter 需要在 AndroidManifest.xml 中定义。通过解析各种intent，从一个屏幕导航到另一个屏幕是很简单的。当向前导航时，activity 将会调用 startActivity(Intent myIntent) 方法。然后，系统会在所有安装的应用程序中定义的 IntentFilter 中查找，找到最匹配 myIntent 的 Intent 对应的 activity。新的 activity 接收到myIntent 的通知后，开始运行。当 startActivity 方法被调用将触发解析 myIntent 的动作，这个机制提供了两个关键好处：

• Activities 能够重复利用从其它组件中以 Intent 的形式产生的一个请求；
• Activities 可以在任何时候被一个具有相同 IntentFilter 的新的 Activity 取代。

AndroidManifest 文件中含有如下过滤器的 Activity 组件为默认启动类，当程序启动时系统自动调用它

<intent-filter>
       <action android:name="android.intent.action.MAIN" />
       <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

2、生命周期：

生命周期： 生命周期指的是 Activity 从 创建 到 销毁 所执行的一系列方法，主要包括7个生命周期方法。

生命周期：onCreate() -> onStart() - > onResume() -> onPause() -> onStop() -> onDestroy()

详细流程如下图

4 个重要状态

1. Resumed：一个新 Activity 启动入栈后，它在屏幕最前端，处于栈的最顶端，此时它处于可见并可和用户交互的激活状态。
2. Paused：一个活动不再处于栈顶位置，但仍然可见时，这时活动就进入了暂停状态，比如对话框形式的活动只会占用屏幕中间的部分区域，你还可以看到后边的界面，这时，后面的活动就处于暂停状态。( 意思就是当 Activity 被另一个透明 或者 Dialog 样式的 Activity 覆盖时的状态。此时它依旧与窗口管理器保持连接，系统继续维护其内部状态，所以它依然可见，但它己经失去了焦点故不可与用户交互。 )
3. Stopped：当一个活动不在处于栈顶位置，并且完全处于不可见的时候，就进入了停止状态，就是进入了一个完全不透明的活动，上个活动会处于停止状态，这时系统仍然会为这种活动保存相应的状态和成员变量，但是这并不是完全可靠的，当其他地方需要内存时，处于停止状态的活动有可能会被系统回收。即当 Activity 被另一个 Activity 覆盖、失去焦点并不可见时处于 Stopped 状态
4. Destroy ：销毁状态，当一个活动从返回栈中移除后就变成了销毁状态，系统倾向于回收处于这种状态的活动，从而保证手机内存充足

摘自《Android从入门到精通》

七大方法详解

1. onCreate：Activity 创建时第一个被调用的方法，通常在该方法中加载布局文件，初始化UI组件，事件注册等等
2. onStart：在 onCreate 方法之后调用，用于显示界面，但用户还不能进行交互( 这个方法在活动由不可见变为可见的时候调用 )
3. onRestart：当一个 stoped 状态的 Activity 被返回时调用，之后再调用 onStart 进入运行状态。( 这个方法在活动由停止状态变为运行状态之前调用，也就是活动被重新启动了。 )
4. onResume：在 onStart 之后调用，该方法执行完成后，用户可以进行交互，当前 Activity 进入 resumed 状态。当一个 paused 状态的 activity 被重新返回时，会再次调用该方法，让 Activity 进入运行状态。( 活动准备好和用户进行交互时调用，此时的活动一定位于返回栈的栈顶，并且处于运行状态 )
5. onPause：当其它 Activity (透明或窗口模式)进入时，该方法会被调用，让当前 Activity 进入 paused 状态(暂停状态)。当前 Activity 还可见但不可交互，如果其它更高优先级的 APP 需要内存时，当前 Activity 可能会被销毁(kill)。当前 Activity 被返回时会调用 onResume 方法。( 在系统准备去启动或者恢复另一个活动的时候调用)
6. onStop：当其它 Activity 覆盖该 Activity 时，会被调用，当前 Activity 进入 stoped 状态(停止状态)。不可见，如果其它更高优先级的 APP 需要内存时，当前 Activity 可能会被销毁(kill)。 当前 Activity 被返回时会调用 onRestart 方法。( 这个方法在活动完全不可见的时候调用 )
7. onDestroy：当前 Activity 被销毁时调用，通常在该方法中用来释放资源，当前 Activity killed。( 这个方法在活动被销毁之前调用，之后活动的状态将变为销毁状态 )

以上七个方法除了onRestart()方法，其他都是两两相对的，从而又可以将活动分为三种生存期

• 一、完整生存期：活动在onCreate()方法和onDestroy()方法之间所经历的，就是完整生存期
• 二、可见生存期：活动在onStart()方法和onStop()之间所经历的，在可见生命期内，活动对于用户总是可见的，即便有可能无法和用户进行交互。
• 三、前台生存期：活动在onResume()方法和onPause()方法之间所经历的，这个生存期内，活动总是处于运行状态，此时的活动是可以和用户进行相互的，我们平时看到和接触最多的也是这个状态下的活动。

菜鸟Android开发系列之：Active的生命周期：https://www.iteye.com/blog/limdengrock-1023926
android Activity生命周期详解(图文)：https://www.iteye.com/blog/104zz-1685753
安卓活动的生命周期：https://blog.csdn.net/QingKing520/article/details/73496618
安卓活动生命周期：https://blog.csdn.net/techdesign/article/details/80456706

活动生命周期示意图：

注：当 AActivity 切换 BActivity 的所执行的方法：

AActivity:    onCreate()->onStart()->onResume()->onPouse()
BActivity:    onCreate()->onStart()->onResume()
AActivity:    onStop()->onDestory()

当 AActivity 切换 BActivity(此 activity 是以 dialog 形式存在的)所执行的方法:

AActivity:    onCreate()->onStart()->onResume()->onPouse()
BActivity:    onCreate()->onStart()->onResume()

另一个图：

• 启动activity：系统先调用onCreate()，然后调用onStart()，最后调用onResume()方法，activity进入运行状态。

• activity被其他activity覆盖其上(DialogActivity)或者锁屏：系统会调用onPause()方法，暂停当前activity的执行。

• 当前activity由被覆盖状态回到前台或者解锁屏：系统会调用onResume()方法，再次进入运行状态。

• 当前Activity转到新的Activity界面或按Home键回到主屏，自身退居后台：系统会先调用onPause方法，然后调用onStop方法，进入停滞状态。

• 用户后退回到此Activity：系统会先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，再次进入运行状态。

• 当前Activity处于被覆盖状态或者后台不可见状态，即第2步和第4步，系统内存不足，杀死当前Activity，而后用户退回当前Activity：再次调用onCreate方法、onStart方法、onResume方法，进入运行状态。

• 用户退出当前Activity：系统先调用onPause方法，然后调用onStop方法，最后调用onDestory方法，结束当前Activity。

• onRestart()：表示activity正在重新启动 ，一般情况下，当前activity从不可见重新变成可见状态时，onRestart()就会被调用，这种情形一般是用户行为所导致的，比如用户按HOME键切换到桌面然后重新打开APP或者按back键。

• onStart()：activity可见了，但是还没有出现在前台，还无法和用户交互。

• onPause()：表示activity正在停止，此时可以做一些存储数据，停止动画等工作，注意不能太耗时，因为这会影响到新activity的显示，onPause必须先执行完，新的activity的onResume才会执行。

• 从activity是否可见来说，onstart()和onStop()是配对的，从activity是否在前台来说，onResume()和onPause()是配对的。

• 旧 activity 先 onPause，然后 新 activity 在启动

注意：当 activity 中弹出 dialog 对话框的时候，activity不会回调onPause。然而当activity启动dialog风格的activity的时候，此activity会回调onPause函数。

异常情况下的生命周期：比如当系统资源配置发生改变以及系统内存不足时，activity就可能被杀死。

• 情况1：资源相关的系统配置发生改变导致 activity 被杀死并重新创建。比如说当前 activity 处于竖屏状态，如果突然旋转屏幕，由于系统配置发生了改变，在默认情况下，activity 就会被销毁并且重新创建，当然我们也可以组织系统重新创建我们的 activity。

系统配置发生改变以后，activity 会销毁，其 onPause，onStop，onDestory 均会被调用，由于 activity 是在异常情况下终止的，系统会调用 onSaveInstance 来保存当前 activity 状态，这个方法的调用时机是在 onStop之前。与 onPause 没有既定的时序关系，当 activity 重新创建后，系统会调用 onRestoreInstanceState，并且把 activity 销毁时onSaveInstanceState 方法保存的 Bundle 对象作为参数同时传递给 onRestoreInstanceState 和 onCreate 方法。onRestoreInstanceState() onStart() 方法后回调。同时，在onSaveInstanceState和onRestoreInstanceState方法中，系统自动为我们做了一些恢复工作，如：文本框(EditeText)中用户输入的数据，ListView滚动的位置等，这些 view相关的状态系统都能够默认为我们恢复。可以查看view源码，和activity一样，每个view都有onSaveInstanceState方法和onRestoreInstanceState方法。

生命周期日志打印：

04-11 09:44:57.350 11757-11757/cn.hotwoo.play:remote I/MainActivity: onCreate
04-11 09:44:57.354 11757-11757/cn.hotwoo.play:remote I/MainActivity: onStart
04-11 09:44:57.356 11757-11757/cn.hotwoo.play:remote I/MainActivity: onResume
04-11 09:44:57.425 11757-11757/cn.hotwoo.play:remote I/MainActivity: onCreateOptionsMenu
04-11 09:44:59.149 11757-11757/cn.hotwoo.play:remote I/MainActivity: onPause
04-11 09:44:59.151 11757-11757/cn.hotwoo.play:remote I/MainActivity: onSaveInstanceState
04-11 09:44:59.151 11757-11757/cn.hotwoo.play:remote I/MainActivity: onStop
04-11 09:44:59.151 11757-11757/cn.hotwoo.play:remote I/MainActivity: onDestroy
04-11 09:44:59.234 11757-11757/cn.hotwoo.play:remote I/MainActivity: onCreate
04-11 09:44:59.235 11757-11757/cn.hotwoo.play:remote I/MainActivity: onStart
04-11 09:44:59.236 11757-11757/cn.hotwoo.play:remote I/MainActivity: onRestoreInstanceState
04-11 09:44:59.237 11757-11757/cn.hotwoo.play:remote I/MainActivity: onResume
04-11 09:44:59.270 11757-11757/cn.hotwoo.play:remote I/MainActivity: onCreateOptionsMenu
04-11 10:02:32.320 11757-11757/cn.hotwoo.play:remote I/MainActivity: onPause
04-11 10:02:32.516 11757-11757/cn.hotwoo.play:remote I/MainActivity: onStop
04-11 10:02:32.516 11757-11757/cn.hotwoo.play:remote I/MainActivity: onDestroy

• 情况2：资源内存不足导致低优先级的activity被杀死
  这里的情况和前面的情况1数据存储和恢复是完全一致的，activity按照优先级从高到低可以分为如下三种：
  (1)前台activity---正在和用户交互的activity，优先级最高
  (2)可见但非前台activity---比如activity中弹出了一个对话框，导致activity可见但是位于后台无法和用户直接交互。
  (3)后台activity---已经被暂停的activity，比如执行了onStop，优先级最低。

防止重新创建activity：activity 指定 configChange 属性来不让系统重新创建 activity。android : configChanges = "orientation"

Activity( 活动 ) 与 Fragment ( 碎片 ) 生命周期关系

创建过程：

销毁过程：

Activity 与 menu 创建先后顺序

在 activity 创建完回调 onResume 后创建 menu，回调 onCreateOptionsMenu

04-05 00:35:03.452 2292-2292/cn.hotwoo.play:remote I/MainActivity: onCreate
04-05 00:35:03.453 2292-2292/cn.hotwoo.play:remote I/MainActivity: onStart
04-05 00:35:03.454 2292-2292/cn.hotwoo.play:remote I/MainActivity: onResume
04-05 00:35:03.482 2292-2292/cn.hotwoo.play:remote I/MainActivity: onCreateOptionsMenu

横竖屏切换时 Activity 的生命周期

此时的生命周期跟清单文件里的配置有关系。

• ① 不设置 Activity 的 android:configChanges 时，横竖屏切换会重新调用各个生命周期，销毁当前 activity，然后重新加载，跟系统配置有关。
• ② onSaveInstanceState()方法会在当前页面销毁前被调用存储数据，onRestoreInstanceState()方法会被执行去取出保存的Bundle对象中的内容，进行一次横竖屏切换时Activity所执行的生命周期方法以及在onSaveInstanceState与onRestoreInstanceState打印相应日志

创建 与 配置

• 创建 一个 Activity 需继承自 android.app.Activity 这个类，然后重写 onCreate()，在 onCreate() 里面调用 setContentView(参数) 来加载布局，参数就是布局文件。
• 配置 则需要在清单文件的 Application 节点下面注册 Actvitiy，如果要首先启动该Activity则添加带有category节点且值为LAUNCHER 的 intent-filter 节点，下面就是清单文件的配置。

<application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

3、 四种启动模式

Activity 的启动模式决定了激活 Activity 时，是否创建新的对象，进而将影响到 任务栈 也叫 回退栈。
在 AndroidManifest.xml 文件中，可以为每个 activity 节点配置 android:launchMode 属性，以决定该 Activity 的启动模式，该属性的值有：

1. Standard 模式 : ( 默认 ) 标准模式：每次激活 Activity 时，都会创建新的 Activity 对象。standard 模式是 android 的默认启动模式，在这种模式下，activity 可以有多个实例，每次启动 Activity，无论任务栈中是否已经存在这个 activity 的实例，系统都会创建一个新的 activity 实例。即 在这种模式下，activity默认会进入启动它的activity所属的任务栈中。 注意：在非activity类型的context(如ApplicationContext)并没有所谓的任务栈，所以不能通过ApplicationContext去启动standard模式的activity。
2. SingleTop 模式： 栈顶模式，也叫栈顶复用模式。当一个 singleTop 模式的 activity 已经位于栈顶位置时，再去启动它时，不会再创建实例，即每次只是激活但并不会创建新的 Activity 对象，如果不在栈顶，就会创建实例。( 如果新activity位于任务栈的栈顶的时候，activity不会被重新创建，同时它的onNewIntent方法会被回调。 注意：这个activity的onCreate，onStart，onResume不会被回调，因为他们并没有发生改变。 )
3. SingleTask 模式 ： 单任务模式，也叫栈内复用模式。如果启动的这个 activity 已经存在于 任务栈 中，则会将该 activity 移动到栈顶，并将该 activity 上面的所有 activity 出栈，否则创建新的实例。( 只要activity在一个栈中存在，那么多次启动此activity不会被重新创建单例，系统会回调onNewIntent。比如activityA，系统首先会寻找是否存在A想要的任务栈，如果没有则创建一个新的任务栈，然后把activityA压入栈，如果存在任务栈，然后再看看有没有activityA的实例，如果实例存在，那么就会把A调到栈顶并调用它的onNewIntent方法，如果不存在则把它压入栈。 )
4. SingleInstance 模式 ：单实例模式，一个 activity 一个栈，即 activity只能单独地位于一个任务栈 中。( 实例(对象)唯一，确保该 Activity 的对象一定只有1个，被设置为 singleInstance 的 Activity 将被置于一个专门的任务栈中，且该任务栈中有且仅有一个 Activity。 )

注意：默认情况下，所有 activity 所需的 任务栈 的名字为应用的包名，可以通过给 activity 指定 TaskAffinity 属性来指定任务栈，***** 这个属性值不能和包名相同，否则就没有意义 *****。

什么 是 任务栈(回退栈)：

任务栈 是 用来存放所有激活了的 Activity 对象，激活的 Acitvity 将会按照后进先出的栈结构显示出来。因为屏幕只能显示一个Activity，当有新的 Activity 被激活时，原来正在显示的 Activity 就会进行压栈操作被压到新 Activity 对象下方的位置。当按下”Back” 键时栈顶 Activity 会执行弹栈操作，而在第 2 位的 Activity 将获得栈顶位置，显示在前台。

4、三种跳转方式

显示启动 ：Intrent 内部直接声明要启动的activity所对应的的class

Intent intent = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intnet);

隐式启动：进行三个匹配，一个是activity，一个是category，一个是data，全部或者部分匹配，应用于广播原理

• 清单文件中 里配置 activity 属性，activity 的名字要和跳转内容一样

<activity 
	android:name="com.exanple.android.tst.secondActivity"
	android:label = @string/title>
	<intent=filter>
		<action android:name="com.exanple.android.tst.secondActivity/>
		<category android:name="android.intent.category.DEFAULT"/>
	<intent-filter/>
</activity>

• 在需要跳转的地方

Intent intent = new Intent("com.example.android.tst.secondActivity");
startActivity(intnet);

跳转后再返回，能获取返回值

Intent in = new Intent(MainActivity.this,OtehrActivity.class);
in.putExtra("a",a);
startActivityForResult(in,1000);

在OTherActivity中设置返回值

Intent int = new Intent();
int.putExtra("c",c);
setResult(1001,int);
finish();

在MainActivity中获取返回值

@Override
protected void onActivityResult(int requestCode, int resultCode	,Intent data) {
	super.onActivityResult(requestCode,resultCode,data);
	if(requestCode == 1000){
		if(resultCode == 1001){
			int c = data.getExtra("c",0);
		}
	}
}

Intent 与 IntentFilter

Intent —— 意图

用于 android 个组件的启动和组件间传递数据

属性:

• component  目标组件描述
• action  对Intent执行动作的描述
• data  对此次Intent操作相关数据的描述
• type  对Intent所关联的数据类型的描述
• category  对Intent执行动作的附加信息描述
• extra  对其他一切附加信息的描述，他是对其他所有附加信息的集合

Intent-Filter —— 意图 过滤器

对 Intent 的描述进行过滤操作，对 Intent 的各个属性进行匹配，从而选择出相应的组件来执行 Intent 想要进行的操作

定义

<Intent-Filter>
  <action name=“xxxxxxxxx”/>
  <action name=“yyyyyyyy”/>
  <category name=“ttttttttttt”/>
  <category name=“uuuuuuu”/>
  <data>
  <data>
</Intent-Filter>

在 IntentFilter 中 action、category、data 都可以存在多个

匹配原则

action：Intent 中的 action 只要和 IntentFilter 中的任意一个 action 一样即可

category：Intent 中添加的 category 必须全部在 IntentFileter 定义的 category 中

data：Intent 中的 data 要和 IntentFilter 中的 data 的描述匹配

type：Intent 中的 type 要和 IntentFilter 中 data 要求的 mimeType 一直

前台进程:

• 1.当前进程activity正在与用户进行交互。
• 2.当前进程service正在与activity进行交互或者当前service调用了startForground()属于前台进程或者当前service正在执行生命周期(onCreate(),onStart(),onDestory())
• 3.进程持有一个BroadcostReceiver,这个BroadcostReceiver正在执行onReceive()方法

可见进程:

• 1. 进程持有一个activity，这个activity不再前台，处于onPouse()状态下，当前覆盖的activity是以dialog形式存在的。
• 2. 进程有一个service，这个service和一个可见的Activity进行绑定。

service进程:

• 当前开启startSerice()启动一个service服务就可以认为进程是一个服务进程。

后台进程:

• activity的onStop()被调用，但是onDestroy()没有调用的状态。该进程属于后台进程。

空进程:

• 改进程没有任何运行的数据了，且保留在内存空间，并没有被系统killed,属于空进程。该进程很容易被杀死。

1.2 service

         service(服务)是安卓中的四大组件之一，它通常用作在后台处理耗时的逻辑，与 Activity 一样，它存在自己的生命周期，也需要在 AndroidManifest.xml 配置相关信息。

        开发人员需要在应用程序配置文件中声明全部的 service，使用 <service></service> 标签。

        Service 通常位于后台运行，它一般不需要与用户交互，因此 Service 组件没有图形用户界面。Service 组件需要继承Service 基类。Service 组件通常用于为其他组件提供后台服务或监控其他组件的运行状态。

定义 与 作用

• Service(服务)是一个没有用户界面的专门在后台处理耗时任务的 Android 组件，它没有UI。它有两种启动方式，startService和bindService。其他应用组件能够启动 Service，并且当用户切换到另外的应用场景，Service将持续在后台运行。另外，一个组件能够绑定到一个service与之交互(IPC机制)，例如，一个service可能会处理网络操作，播放音乐，操作文件I/O或者与内容提供者(content provider)交互，所有这些活动都是在后台进行，以上是Google文档的解释，资料来源于大神博客( https://blog.csdn.net/ryantang03/article/details/7770939 )
• Service 还有一个作用就是提升进程(每个应用都是一个进程)的优先级，进程的优先级指的是在 Android 系统中，会把正在运行的应用确定一个优先级，当内存空间不足时，系统会根据进程的优先级清理掉一部分进程占用的内存空间，以获得足够的内存空间以供新启用的应用运行。详细的进程优先级划分如下：
          1)   前台进程：应用程序存在Activity正位于前台，可见并可控
          2)   可见进程：应用程序存在Activity处于局部可见状态，即局部可见却不可控
          3)   服务进程：应用程序存在正在运行的Service
          4)   后台进程：应用程序的所有Activity均被置于后台，没有任何Activity可见
          5)   空进程：已经退出的应用程序。
  service 的进程优先级详细介绍请参考这篇博文：https://blog.csdn.net/fhy_2008/article/details/7328967

service 特性

• 【1】Service 的粘性：
  当 Service 被意外终止(非正常停止，即不是通过 stopService() 或 stopSelf() 停止)后，会在未来的某一刻自动重启。
  Service 的粘性是通过 onStartCommand() 方法的返回值确定的，可用的值有：
  —–  Service.START_REDELIVER_INTENT    ----->    粘性的，且在自动重启时，会重新给Service发送Intent对象。
  —–  Service.START_STICKY                           ----->    粘性的
  —–  Service.START_NOT_STICKY                 ----->    非粘性的
  —–  Service.START_STICKY_COMPATIBILITY     ----->    粘性的，并且兼容的
  当需要 Service 是非粘性的，取值 Service.START_NOT_STICKY；当需要 Service 是粘性的，并且还需要获取 Intent 对象时，取值 Service.START_REDELIVER_INTENT；否则，只是需要粘性的，不需要 Intent 时，取值super.onStartCommand() 默认值。
• 【2】Service 是单例的，在程序中一个 Service 类只会存在一个对象
• 【3】Service 是没有界面的，适合于在后台进行耗时操作，但要注意 Service 仍然是运行在主线程中的，故耗时的操作还是需要开启子线程来进行。

service 用于在 后台 完成用户指定的操作，service 有 2 种启动方式

• 第一种启动方式：通过 start 方式开启服务，即 startService(启动)。started(启动)：当应用程序组件(如 activity)调用 startService() 方法启动服务时，服务处于 started 状态。
  使用 service 的步骤：
          1，定义一个类继承 service
          2，manifest.xml 文件中配置 service
          3，使用 context 的 startService(Intent) 方法启动 service
          4，当不在使用时，调用 stopService(Intent) 方法停止服务。

  
  使用 start 方式启动的生命周期：onCreate() -- > onStartCommand() -- > onDestory()

  注意：如果服务已经开启，不会重复回调 onCreate() 方法，如果再次调用 context.startService() 方法，service 而是会调用onStart() 或者 onStartCommand() 方法。停止服务需要调用 context.stopService() 方法，服务停止的时候回调 onDestory 被销毁。

  特点：一旦服务开启就跟调用者(开启者)没有任何关系了。开启者退出了，开启者挂了，服务还在后台长期的运行，开启者不能调用服务里面的方法。

• 第二种启动方式：采用 bind 的方式开启服务，即 bindService(绑定服务)。bound(绑定)：当应用程序组件调用 bindService() 方法绑定到服务时，服务处于 bound 状态。
  使用 service 的步骤：
          1，定义一个类继承 Service
          2，在 manifest.xml 文件中注册 service
          3，使用 context 的 bindService(Intent, ServiceConnection, int) 方法启动 service
          4，不再使用时，调用 unbindService(ServiceConnection) 方法停止该服务。

  
  使用这种 bind 方式启动的 service 的生命周期如下：onCreate() -- > onBind() --> onUnbind() -- > onDestory()

  注意：绑定服务不会调用 onStart() 或者 onStartCommand() 方法

  特点：bind 的方式开启服务，绑定服务，调用者挂了，服务也会跟着挂掉。绑定者可以调用服务里面的方法。

下图形象地说明了 Service 两种状态的生命周期

通过这个图可以看到，两种启动 service 的方式以及他们的生命周期，bind service 的不同之处在于当绑定的组件销毁后，对应的service 也就被 kill 了。service 的声明周期相比与 activity 的简单了许多，只要好好理解两种启动 service 方式的异同就行。

startService() 与 bindService() 区别：

• startService 是由其他组件调用 startService() 方法启动的，只是启动 Service，这导致服务的 onStartCommand() 方法被调用。当服务是 started 状态时，其生命周期与启动它的组件无关，并且可以在后台无限期运行，即使启动服务的组件已经被销毁。因此，服务需要在完成任务后调用 sto