知识库

public void MyFunction(){
HttpClient httpclient = new DefaultHttpClient();
  HttpPost httppost = new HttpPost("ht tp://ways2u.com");
  try {
   List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2);
   nameValuePairs.add(new BasicNameValuePair("id", "12345"));
   nameValuePairs.add(new BasicNameValuePair("stringdata", "fff"));
   httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
   HttpResponse response = httpclient.execute(httppost);
   HttpEntity entity = response.getEntity();
   InputStream content = entity.getContent();
  } catch (ClientProtocolException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
}

标签: android http

大多数操作系统，在应用程序所寄存的可执行程序映像（如Windows系统里的.exe）、它所运行的进程以及和用户交互的图标和应用之间有一种严格的1对1关系。在Android系统里，这些关联要松散得多。并且重要的是要理解各种概念怎么样组成整体。
由于Android应用固有的灵活性，当实现这些不同方面的时候有一些基本术语需要加以理解：
一个Android包 （.apk）文件，其中包含一个应用程序的代码和资源。这是应用程序分发和下载的文件，用户用来安装该应用程序在他们的设备上。
一个任务一般而言是指用户视为的一个可启动应用程序：通常任务在桌面（home screen）有一个可访问的图标，且可以被切换到前台。
一个进程是一个运行着应用程序代码的底层核心过程。通常所有.apk里的代码运行在一个专有的进程里。不过，进程标记也可以用来限定代码运行位置，或者为整个.apk或者为个别的活动activity，接收者receiver，服务或提供者provider，组件。
任务
这里的一个关键点是：当用户看到一个“应用”时，他们实际上在和任务打交道。如果您刚刚创建一个包含若干活动的.apk，其中之一是顶层入口点（通过动作android.intent.action.MAIN的意图过滤器intent-filter和类别android.intent.category.LAUNCHER），那么这事实上将为您的.apk创建一个任务，并且您从那儿起动的任何活动都将作为那个任务的一部分运行。
一个任务，那么，从用户的角度来看是您的应用程序;而从应用程序开发者的角度来看，它是一个或多个用户在那个任务中已经经历过且未关闭的活动，或者说是一个活动栈。一个新的任务通过以Intent.FLAG_ACTIVITY_NEW_TASK标志起动一个活动意图来创建;这一意图将被用来作为任务的根意图，定义任务是什么。任何不以这个标志起动的活动将和起动它的活动在相同的任务中运行（除非该活动已请求特别启动模式，稍后会讨论）。任务可以被重新安排：如果您使用FLAG_ACTIVITY_NEW_TASK标志但已经有一个任务以这个意图运行，则当前任务的活动栈将被切换到前台而不是开始一个新的任务。
 
FLAG_ACTIVITY_NEW_TASK必须谨慎使用：使用它意味着，在用户看来，一个新的应用程序由此起动。如果这不是你所期望的行为，你就不该去创建一个新的任务。另外，仅在用户可以从桌面返回到他原来的地方和以一个新任务启动相同意图的情况下，你才应该使用新的任务标记。否则，如果用户在你已经启动的任务里按桌面（HOME）键，而不是返回（BACK）键，你的任务及其活动将被放置到桌面后面，没有办法再切换回去。
 
 
任务共用性Affinity
在某些情况下，Android需要知道一个活动属于哪个任务即使它没有被启动到一个具体的任务里。这是通过任务共用性（Affinities）完成的。任务共用性（Affinities）为这个运行一个或多个活动的任务提供了一个独特的静态名称，默认的一个活动的任务共用性（Affinity）是实现了该活动的.apk包的名字。这提供了预期的标准特性，即所有在一个特定的.apk包里的活动是单个用户应用程序的一部分。
当开始一个没有Intent.FLAG_ACTIVITY_NEW_TASK标志的活动时，任务共用性affinities不会影响将会运行该新活动的任务:它总是运行在启动它的任务里。但是，如果使用了NEW_TASK标志，那么共用性（affinity）将被用来判断是否已经存在一个有相同共用性（affinity）的任务。如果是这样，这项任务将被切换到前面而新的活动会启动于这个任务的顶层。
 
这种特性在您必须使用NEW_TASK标志的情况下最有用，尤其是从状态栏通知或桌面快捷方式启动活动时。结果是，当用户用这种方式启动您的应用程序时，它的当前任务将被切换到前台，而且想要查看的活动被放在最上面。
你可以在程序清单（Manifest）文件的应用程序application标签中为.apk包中所有的活动分配你自己的任务共用性Affinites，或者在活动标记中为各个活动进行分配。一些说明其如何使用的例子如下：
如果您的.apk包含多个用户可以启动的高层应用程序，那么您可能需要对用户看到的每个活动指定不同的affinities。一个不错的命名惯例是以附加一个以冒号分隔的字符串来扩展您的.apk包名。例如，“ com.android.contacts ”.apk可以有affinities:“com.android.contacts：Dialer”和“ com.android.contacts：ContactsList”。
如果您正在替换一个通知，快捷方式，或其他可以从外部发起的应用程序的“内部”活动，你可能需要明确设定您替代活动的taskAffinity和您准备替代的应用程序一样。例如，如果您想替换contacts详细信息视图（用户可以创建并调用快捷方式），你得把taskAffinity设置成“com.android.contacts”。
启动模式和启动标志
 
您控制活动和任务交互的主要途径是通过活动的launchMode 属性和意图相关的标志flags。这两个参数可以以各种方式合作来控制活动启动的结果，正如它们相关文档中描述的那样。在这里，我们将看看一些常见的用例和参数组合。
你将使用的最常见的启动模式（除了默认的standard模式）是singleTop。这并不影响任务;它只是避免多次在一个堆栈顶部起动同一活动。
 
singleTask启动模式对任务有重大的影响：它使活动始终是开始于一项新的任务（或其现有的任务被带到前台） 。使用这种模式需要谨慎对待你如何与系统其他部分进行交互，因为这影响到这个活动中的每一个路径。它应当仅在活动处于应用程序前台时使用（也就是支持MAIN动作和LAUNCHER类别）。
singleInstance启动模式更是专业，并应仅用于整个就是被实现为一个活动的应用程序中。
有一种你会经常遇到的情况是当另一个实体（如SearchManager 或NotificationManager）开始您的一个活动。在这种情况下，必须使用Intent.FLAG_ACTIVITY_NEW_TASK 标签，因为该项活动是在任务之外起动的（而且应用/任务可能根本不存在）。正如前面所述，这种情况下的标准行为是把匹配新活动affinity的任务带到前台和在此之上起动新的活动。不过，也有其他您可以实施的行为类型。
其中一种常见的做法是，还可以使用Intent.FLAG_ACTIVITY_CLEAR_TOP 国旗与NEW_TASK 。通过这样做，如果你的任务已经运行，那么将提请前景，所有的活动，其堆栈清除除根系活力和根系活力的onNewIntent （意图） 所谓的意图正在开始。请注意，该活动还常常使用singleTop 或singleTask 发射模式时，使用这种方法，因此，目前的情况是由于新的意图而不需要将它摧毁，一个新的实例开始。
 
一种通常的办法是和NEW_TASK联合起来使用Intent.FLAG_ACTIVITY_CLEAR_TOP标志。这样，如果您的任务已经运行，那么它将会被带到前台，除根活动外其它所有堆栈中的活动都被清除，而且这个根活动的方法onNewIntent(Intent)会在该意图起动时被调用。注意这个活动使用这个方法时经常使用singleTop或者singleTask起动模式，这样当前实例被赋予新的意图而不是需要销毁它然后重新起动一个新的实例。
 
您能采取的另外的方法是设置通知活动的任务affinity为空字符串“”（表示没有affinity），并设置finishOnBackground属性。这种方法是有用的如果你希望这个通知把用户带到一个单独的描述它的活动中，而不是返回到应用程序的任务。通过指定这个属性，该活动将被结束不管用户通过BACK还是HOME离开它;如果这个属性没有指定，按首页将导致这个活动及其任务仍保留在系统里，且可能没有办法返回它。
请务必阅读关于launchMode属性和Intent标志的文档以获取这些选项的详细说明。
 
进程

在Android里，进程完全是应用的实现细节，而不是用户通常了解的那样。其主要用途就是：
通过安置不受信任的或不稳定的代码到另一个进程来提高稳定性或安全性。
通过在同一进程里运行多个.apks的代码来减少开销。
通过把重量级代码放在单独的进程中来帮助系统管理资源，该进程可以在不影响应用程序其他部分的情况下被终止。
正如前面所述，这个进程属性用来控制运行着特定应用程序组件的进程，注意，此属性不能用于违反系统安全性：如果有两个不共享相同用户ID的.apks尝试运行在同一进程中，这将不会被允许，相反会为它们每一个创建不同的进程。
参见安全 文档以获取更多关于安全限制方面的信息。
 
线程
每个进程包含一个或多个线程。多数情况下，Android避免在进程里创建额外的线程，以保持应用程序单线程，除非它创建自己的线程。一个重要的结果就是所有对活动Activity，广播接收器BroadcastReceiver以及服务Service实例的调用都是由这个进程的主线程创建的。

注意新的线程并不会为每个活动，广播接收器，服务或者内容提供器（ContentProvider）实例而创建：这些应用程序的组件在进程里被实例化（除非另有说明，都在同一个进程处理），实际上是进程的主线程。这说明当被系统调用时没有哪个组件（包括服务）会进行远程或者阻塞操作（就像网络调用或者计算循环），因为这将阻止进程中的所有其他组件。你可以使用标准的线程类Thread或者Android的HandlerThread便捷类去对其它线程执行远程操作。

这里有一些关于这个线程规则的重要的例外：

  ・ 对IBinder或者IBinder实现的接口的调用由调用线程或本地进程的线程池（如果该呼叫来自其他进程）分发，而不是它们的进程的主线程。特殊情况下，一个服务的IBinder可以这样调用。（尽管调用服务里的方法已经在主线程里完成。）这意味着IBinder接口的实现必须要有一种线程安全的方法，这样任意线程才能同时访问它。
  ・ 对ContentProvider主要方法的调用由调用线程或者主线程分发,如同IBinder一样。被指定的方法在内容提供器的类里有记录。这意味着实现这些方法必须要有一种线程安全的模式，这样任意其它线程可以同时访问它。
  ・ 视图及其子类中的调用由正在运行着视图的线程产生。通常情况下，这会被作为进程的主线程，如果你创建一个线程并显示一个窗口，那么继承的窗口视图将从那个线程里启动。
 

标签: android

Android应用程序是用Java语言写的，通过aapt工具把应用程序所需要的任何数据、资源文件打包成apk文件，这个文件是一个将应用安装到手机上的一个载体。
有很多方式，每个Android应用程序存在于不同的世界：
　　(1)默认的，每个应用在他自己的Linux进程中运行，当应用中的任何代码需要执行时Android就启动相应的进程，当不需要执行时并且系统资源被其他应用请求时android就关闭相应的进程。
　　(2)每个进程都有他自己的虚拟机对象(VM)，所以应用程序代码与其他的应用运行是彼此隔离的。
　　(3)默认的，每个应用被分配一个唯一的Linux user ID，都被设置权限以便应用程序的文件只对用户可见或者只对应用自己可见。
　　安排两个应用程序共享一个user ID是可能的，这种情况下他们彼此之间是可以看见对方的文件的，为了保护系统资源，拥有相同ID的应用也能被安排运行在一个相同的Linux进程中，共享相同的VM。
1、应用组件(Application Components)
　　Android一个核心的特点就是一个应用能使用另一个应用的元素(如果另一个应用允许的话)，你的应用不需要包含你用到的另一个应用的代码也不需要你连接这些代码，相反的，只是当应用需要这些代码时，就启动另一个应用相应的代码(不是让另一个应用全部启动)
　　为了这个能工作，当一个应用的任何部分被需要时系统必须能启动这个应用进程，并且将这个部分实例化成java对象，因此，和其他大多数系统不同的是，android应用程序没有一个单独的程序入口(例如：没有main()函数)，相反的，android应用有必要的组件以便当需要时系统能实例化并运行它，android中有四种组件：
　　(1)Activity
　　一个Activity是一个可见的用户可以使用的用户界面，如果一个应用中有多个Activity，虽然彼此结合形成一个应用在一起工作，但是每个Activity是彼此独立的，每个都是Activity的一个子类。
　　一个应用程序可能由一个或多个Activity组成，这些Activity这么样显示，需要多少个Activity，依赖于这个应用的设计者，一般的，有一个Activity应该被标记成当这个应用启动时第一个呈现出来给用户的。
　　每个Activity默认的被给予一个窗口来绘制，一般的，这个窗口占满整个屏幕，但是他可以比屏幕小并且浮在另一个窗口的上面。
　　一个窗口中的可见的内容是由一些具有层次关系的view组成的，都是继承自View类的，每个view都控制一个窗口中的特定的矩形框，parent view 包含children view和组织children view的布局，leaf view(那些在继承层次最底层的view)绘制在他们所控制的矩形框中，并且对用户的动作做出直接的回应，因此view就是Activity和用户交互的地方，android有很多已经做好的view你可以使用，包括buttons，text fields，scroll bars，menu items，check boxes等等
　　一个view hierarchy是通过Activity.setContentView()方法被放到一个Activity的window中的，content view是view hierarchy中最顶端的那个view。
　　(2)Services
　　一个service不是一个用户可见的组件，在不确定的一段时间内运行在后台，每个service都继承自Service类。
　　你可以连接(connect)或者绑定(bind)到一个正在运行的service(如果这个service还没运行的话就启动它)，当连接到service后，你可以通过一个service暴露出来的接口和这个service交流，对music service来说，这个接口可以是允许用户暂停，后退，停止，重新播放。
　　和Activity或者其他组件一样，service运行在这个应用进程的主线程中，所以他不会阻塞其他的组件或者用户界面，他们经常为那些耗时长的任务单独开一个线程。
　　(3)Broadcast receivers
　　一个broadcast receiver这样一个组件，他只是接收广播并作出反应，在系统中有很多已有的广播，比如反应时区变化(timezone)的，电池变化(battery)的，用户修改了系统语言时的广播，应用程序也可以自己定义广播，比如定义这样一个广播，让其他的应用知道某些数据已经下载完毕了可以使用了。
　　一个应用可以有任意多个broadcast receiver来对他所关心的广播进行监听并作出反应。所有的receiver都继承自BroadcastReceiver类。
　　BroadcastReceiver不显示在用户界面上，然而，他们可以启动一个Activity来作为他们接收到的信息一种反应，或者他们可以使用NotificationManager来提示用户，Notifications可以通过不同的方式获得用户的注意，比如点亮呼吸灯，震动电话，播放一个声音等等，他们一般放一个图标在状态栏上，来让用户可以打开获得这些信息。
　　(4)Content providers
　　Content providers是一个应用程序数据的集合，来让其他的应用可以访问这些数据，这些数据可以被存在文件系统中，SQLite数据库中，或者其他可以存数据的地方，Content providers是一个基本的方法集合来使其他的应用可以获得和存储这些数据，然而应用不直接调用这些方法，而是使用一个ContentResolver对象来调用这些方法，一个ContentResolver可以和任何的Content providers交流，他和provider协作来管理系统中任何进程间的通信。
　　无论何时一个请求都应该由一个特定的组件来处理，android系统来确保包含这个组件的应用进程运行，如果需要就启动它，如果需要就为这个组件创造一个实例，确保这个组件的一个适当的实例可以被得到。
2、启动组件：intent
　　当有一个来自于content resolver的请求指向Content provider时，content provider启动，其他的三个组件(Activity，service，broadcast receiver)是通过一个叫做intent的异步的消息来启动的，一个intent持有一个message的内容，对Activity和service来说，他是一个被要求的动作(action)和在该动作上的数据的URI，对broadcast receiver来说，intent对象是一个被广播的动作。
　　针对每种组件分别有对应的方法来启动它：
　　(1)一个Activity是通过传递一个Intent对象到Context.startActivity()或者Activity.startActivityForResult()来启动的(或者去做一些新的任务)，被启动的这个Activity可以通过getIntent()来获得导致他启动的那个intent的。
　　(2)一个service是通过传递一个Intent对象到Context.startService()来启动的(或者给一些新的命令给正在运行的service)，android调用service的onStart()方法，并且把Intent对象传递给他，同样的，一个Intent可以传递到Context.bindService()方法里来建立一个介于正在运行的service和调用他的组件之间的连接，这个service通过onBind()方法来接收这个Intent对象，(如果这个service还没有运行，bindservice()能选择性的启动它)，在后面的部分，关于绑定service的更多详细的信息请查看远程调用。
　　(3)一个应用可以通过传递一个Intent对象给像Context.sendBroadcast(), Context.sendOrderedBroadcast(), Context.sendStickyBroadcast()这样的方法来开始一个广播，android通过调用对应的onReceive()方法将intent传递给所有对这个广播感兴趣的broadcast receiver。
3、关闭组件(Shutting down components)
当对来自于content resolver的请求作出回应时content provider就启动了，当有一个感兴趣的broadcast message被广播时，broadcast receiver启动，所以我们需要知道怎么关闭这些组件。
　　(1)Activity可以通过调用它自己的finish()方法来关闭，一个Activity也可以通过调用finishActivity()来关闭另一个Activity(这个Activity是通过调用startActivityForResult()来启动的)。
　　(2)一个service可以通过调用自己的stopSelf()，或者Context.stopService()来关闭。
　　当组件不再使用时或者android为了更多组件能运行而回收内存时，android系统是关闭这些组件的，在后面的部分，可以在组件的生命周期中看到更多更详细的介绍
4、Activities and Tasks
　　一个Activity可以启动另一个Activity，即使这个Activity是定义在另一个应用里的，比如说，你想展示给用户一条街的地图，现在已经有一个Activity可以做这件事，那么现在你需要做的就是将你请求的信息放进一个Intent对象里，并且通过startActivity()传递给他，这个地图就可以显示出来了，但用户按下BACK键时，你的Activity又重新出现在屏幕上。
　　对用户来说，显示地图的Activity和你的Activity好像在一个应用中的，即使是他们是定义在不用的应用中的，运行在各自的应用进程中，android将两个Activity放进一个task里，一个task是一组彼此联系的Activity，被安排在一个堆栈中，堆栈中的根Activity就是开辟这个task的，一般的，他是用户选择应用后首先启动的那个Activity，堆栈顶部的Activity是当前正在运行的Activity，当一个Activity启动另一个Activity时，新的Activity被压进堆栈中，成为运行的Activity，当用户按下BACK键，当前的Activity弹出堆栈，先前的Activity恢复成为运行的Activity。
　　一个task就是一组Activity的堆栈，不是在manifest文件里的一个类，一个元素，所以没有方法来为一个task里的Activity独立的设置值，对task设置值是在root Activity里设置的。
　　一个task里的所有Activity组成一个单元，整个task(整个Activity堆栈)可以在前台，也可以在后台(应用程序的切换就是task的前后台的切换)，假设，当前的task有四个Activity在堆栈里，用户按下HOME键，去开启另一个应用(实际上是一个新的task)，那么当前的task就退到后台运行，新开启的应用的root Activity此时就显示出来了，然后，过了一段时间，用户回到主界面，又重新选择了以前的那个应用(先前的那个task)，那么先前的那个task此时又回到了前台了，当用户按下BACK键时，屏幕不是显示刚刚关闭的那个应用，而是移除回到前台的这个task堆栈栈顶Activity，将下一个Activity显示出来。
　　刚才描述的情况是Activity和task默认的行为，但是有很多的方法来对几乎所有的方面进行修改，如Activity和task的联系。task里Activity的行为，是受启动它的Intent对象的flag和在manifest文件中的Activity的属性集合共同影响的。
　　Flag：
　　FLAG_ACTIVITY_NEW_TASK
　　FLAG_ACTIVITY_CLEAR_TOP
　　FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
　　FLAG_ACTIVITY_SINGLE_TOP
　　属性：
　　taskAffinity
　　launchMode
　　allowTaskReparenting
　　clearTaskOnLaunch
　　alwaysRetainTaskState
　　finishOnTaskLaunch
5、Affinities and new tasks
　　默认的，一个应用里的所有Activity都有联系，所有都是属于一个task的，然而，可以通过下的taskAffinity属性来为每个Activity单独的设置属性关系，定义在不同应用中的Activity可以共享一种关系(affinity)，或者定义在同一个应用中的Activity可以分配不同的关系(affinity)。这种关系在两种情况下生效，当启动Activity的 Intent对象包含有FLAG_ACTIVITY_NEW_TASK标志，一个Activity的allowTaskReparenting属性设置为true。
　　FLAG_ACTIVITY_NEW_TASK
　　一个Activity调用startActivity()启动一个新的Activity时，新的Activity会压入到相同的task中的，如果传递给startactivity()的Intent对象含有FLAG_ACTIVITY_NEW_TASK标志，系统就会寻找一个新的task来装这个新的Activity，然而，也不总是这么做，如果已经有一个task和这个新的的Activity有相同的关系，那么就把这个新的Activity放进这个task里，如果没有，就启动一个新的task。
　　allowTaskReparenting属性
　　如果一个Activity的allowTaskReparenting属性设置为true，这个Activity就可以从启动时的那个task移动到一个和他有关系的当前在前台的一个task里，比如，假设现在有一个天气预报的Activity被定义在一个旅行的应用里，他和这个应用里的其他Activity有相同的关系(默认的关系)，并且他允许reparenting，现在你自己应用有一个Activity启动这个天气预报的Activity，那么天气预报Activity就会移动到你的Activity所在的task里，当旅行的应用又回到前台时，天气预报Activity重新回到以前的那个task并显示。(个人观点：如果说没有设置这个属性，或者这个属性设置为false，那么一个应用里的Activity调用另一个应用里的Activity时，系统是为另一个应用里的Activity创建一个实例，然后放到同一个task里，但是如果设置了allowTaskReparenting为true，那么另一个应用里的Activity是可以在不同的task间来回移动的，那个task在前台就移动到那个task里)
6、启动方式
　　下的launchMode属性可以设置四种启动方式：
　　"standard" (the default mode)
　　"singleTop"
　　"singleTask"
　　"singleInstance"
　　这些不同的方式可以从下面的四点来说：
　　(1)对一个Intent作出回应时哪个task应该去持有这个Activity。
　　对standard和singleTop方式来说，新的Activity和通过startActivity调用他的Activity处在同一个task中，如果调用时Intent对象里含有FLAG_ACTIVITY_NEW_TASK标志，那么就像前面讲的那样的寻找一个新的task。
　　相反的，singTask和singleInstance方式，总是标志Activity为task的root Activity，他们不会进入到其他的task中。
　　(2)一个Activity是否可以有多个实例。
　　一个standard或者singleTop属性的Activity可以实例化多次，他们可以属于多个不同的task。
　　相反的，singleTask或者singleInstance属性的Activity只能有一个实例(单例)。
　　(3)实例是否能允许在task里有其他的Activity。
　　一个singleInstance属性的Activity单独的在他自己的task里，并且这个task里只能有他自己一个Activity，如果他启动了另一个Activity，那个Activity会根据启动模式来启动并装进一个不同的task里。其他的方面，singleInstance和singleTask一样的。
　　其他三个方式允许有多个Activity在一个task里，一个singleTask属性的Activity总是一个task里的root Activity，但是他可以启动另外的Activity并且将这个新的Activity装进同一个task里，standard和singleTop属性的Activity可以出现在task的任何地方。
　　(4)一个类(Activity)的对象是否可以被启动来处理一个新的Intent。
　　对默认的standard方式，会实例化一个对象来处理每一个新的Intent，每个实例处理一个新的Intent，对singleTop方式，如果一个已经存在的实例是在task的栈顶，那么就重用这个实例来处理这个新的Intent，如果这个实例不在栈顶，那就不复用他，而是重新创建一个实例来处理这个新的Intent并且将这个实例压入堆栈。
　　例如现在有一个task堆栈ABCD，A是root Activity，D是栈顶Activity，现在有一个启动D的Intent来了，如果D是默认的standard方法，那么就会创建一个新的实例来处理这个Intent，所以这个堆栈就变为ABCDD，然而如果D是singleTop方式，这个已经存在的栈顶的D就会来处理这个Intent，所以堆栈还是ABCD。D此时调用onNewIntent()，此时D可以调用getIntent()来获得最初的Intent，或者调用setIntent()来更新这个Intent。
　　如果现在有一个Intent来启动B，不管B是standard还是singleTop(因为现在B不在栈顶)，都会创建一个新的实例，所以堆栈变为ABCDB
　　在一个task里，对singleTask和singleInstance属性的Activity只能有一个实例。所以这仅有的一个会来处理所以的Intent，一个singleInstance属性Activity总在栈顶(因为task里就只有他一个Activity)，所以他会处理所以的Intent，但是一个singleTask属性的Activity必须是task的root Activity(也就是必须在栈底)，不能确定他的上面是否还有其他的Activity，如果没有，就可以处理，如果还有其他的Activity，那么如果现在有一个Intent来启动这个singleTask属性的Activity，这个Intent将会被丢掉(即使是这个Intent被丢掉，他的到来还是会导致这个task回到前台)。
　　当创建一个类(Activity)的实例来处理一个新的Intent时，用户可以按下BACK键回到上一个Activity，但是如果是用已经存在的栈顶的Activity来处理Intent的话，按下BACK键是不能回到以前的状态的(没处理这个Intent之前)。
　7、清理堆栈
　　当用户离开一个task一段时间后，系统就会清理掉task里出了rootActivity以外的Activity，如果用户又回来了，显示的是rootActivity，就像是用户离开又回来，是放弃以前的东西，开始新的东西。
　　上面说的是默认的情况，有一些Activity的属性可以用来控制和修改这些行为。
　　alwaysRetainTaskState
　　如果一个task里的root Activity的alwaysRetainTaskState属性设置为true，那么前面描述的默认情况就不会出现了，task即使过了一段时间也会一直保留所有的Activity。
　　clearTaskOnLaunch
　　如果一个task里的root Activity的clearTaskOnLaunch属性设置为true，和alwaysRetainTaskState相反，即使是一瞬间的离开，系统马上就会清理掉task里出rootActivity以外的所有Activity。
　　finishOnTaskLaunch
　　这个属性和clearTaskOnLaunch一样，但是他是对一个Activity起作用，不是整个task，他能引起所有的Activity离开，包括root Activity，当这个属性设置为true，只是当用户使用这个应用时Activity才在task里，一旦用户离开后重新回来，显示的不是当前的界面。
　　还有其他的方法来从task里强制移动Activity，如果一个Intent对象里包含FLAG_ACTIVITY_CLEAR_TOP标志，并且目标task里已经一个在自己task里可以处理Intent的Activity(就是处理这个Intent无需实例化另外一个Activity)，那么在这个Activity之上的所有Activity将被清除，能处理这个Intent的Activity就移到栈顶来处理这个Intent，例如ABCD堆栈，含有FLAG_ACTIVITY_CLEAR_TOP标志的Intent来启动B，那么清除CD，B到达栈顶来响应Intent，此时是AB，如果B设置了standard属性，那么还是清楚CD，然后再创建一个实例来响应Intent，此时是ABB，因为standard属性的Activity总是创建一个新的实例来响应新的Intent。
8、进程和线程(Processes and Threads)
　　当一个应用的第一个组件需要运行时，android系统就为这个组件启动一个只有一个线程的Linux进程，默认的，应用的所有组件都运行这个进程中的这个线程中。
　　但是，你可以安排组件运行在其他的进程中，并且为你的任意的进程增加若干线程。
　　1、 进程
　　组件运行的进程是在manifest文件里控制的，四大组件都一个process属性可以指定进程来运行，这些属性可以被设置为了每个组件都可以运行在他自己的进程中，或者几个组件共享一个进程，或者不共享，如果两个应用共享一个Linux user ID并且有相同的权限，那么就可以使这两个应用中的组件运行在相同的进程中，也有process属性，用来指定对所有组件的属性。
　　所有的组件都在指定的进程中的主线程中实例化，系统调用这些组件就是从主线程里发出的，其他的线程将不会对每个组件再实例化，所有作为调用的回应的这些方法，比如说View.onKeyDown()还是组件的生命周期函数等等都是运行在这个主线程中的，这就意味着当系统调用这个组件时，这个组件不能长时间的阻塞线程(比如说网络操作，循环计算)，因为这样会阻塞这个进程中的其他组件，你可以将很耗时的任务分到其他的线程中。
　　当内存不足或者有其他更紧急的进程要求时，Android系统可能关闭一个进程，运行在这个进程中的应用组件因此被销毁，当用户又重新回来时，进程才被重新启动。
　　至于究竟要停止哪个进程，android系统是通过衡量哪个进程对用户来说更重要来实现的
　　2、 线程
　　你可以限制你的应用运行在一个进程中，但是有的时候你需要新开一个线程在后台运行，用户界面需要随时对用户的要求做出反应，所以一些很耗时的工作应该重新启动一个线程来做，以免阻塞主进程。
　　Android系统提供了一系列方便的类来管理线程(Looper，Handler，HandlerThread)
　　3、 远程调用(Remote procedure calls)
　　Android系统有一个轻量级的远程调用机制(RPC)-----一个方法在本地调用，但是在远程执行(在另外一个进程里)，返回给调用端的所有结果都必须的系统能理解的，将数据从本地进程和地址空间传递到远程的进程和地址空间，并在远端重新装配，返回值的时候传输方向相反，android系统会去做这些传输的工作，让你能够集中精力来定义你的RPC
　　一个RPC接口只能包含方法，默认的，即使是没有值返回，所有的方法都是同步执行的，就是说本地方法一直会阻塞直到远端的方法执行完毕)。
　　简单的说，这个远程调用的机制是这样工作的：
　　首先你需要用IDL(interface definition language)声明你的RPC接口，然后android系统会使用aidl工具来形成一个java接口，并且这个java接口是本地进程和远端进程都可以获得的，这个java接口包含了两个内部类，请看下图：
　　
　　这两个内部类有管理远程调用(你用IDL声明的接口)的所以代码,两个内部类都实现IBinder接口,一个是在本地(内部)使用,这个你可以不用自己写代码，另外一个叫做Stub，继承自Binder类的，包含所有完成进程间通信(IPC)的代码，他包含你在RPC接口中声明的所有方法，你应该继续继承Stub类来实现这些方法。
　　一般的，远端进程应该由一个service来管理(因为一个service能通知系统关于这个进程和他连接到的其他进程)。
9、进程的生命周期(Processes and lifecycles)
　　Android系统总是尽最大的努力来维持一个应用的进程，但系统的内存不足时就可能需要关闭一些旧的进程了，但是决定关闭哪个进程呢，android系统把所以的进程放进一个重要性树里，最低重要性的进程将会被停止，系统有5种重要性等级，重要性从高到低如下：
　　(1)、前台进程。一个前台进程是当前执行用户请求的进程，如果有如下的一种情形的那么他就是前台进程：
　　a、这个进程里运行着一个正在和用户交互的Activity(这个Activity的onResume()方法被调用)。
　　b、这个进程里有绑定到当前正在和用户交互的Activity的一个service
　　c、这个进程里有一个service对象，这个service对象执行了至少一个他生命周期的函数(onCreate(), onStart(), or onDestroy()).
　　d、这个进程里有一个执行了onReceive()方法的broadcastreceiver对象
　　只有一定数量的前台进程在任何时间都存在，他们只有在最后的时刻被停止---系统的内存太少了而不能运行这些仅有的前台进程了)，一般的，在那个时刻，手机会重新设置内存页的状态，所以停止一些前台的进程是为了保持对用户操作的快速响应。
　　(2)可见进程。一个可见进程一个没有任何前台显示的组件，但是仍然可以影响到用户当前屏幕所看见的东西，如果有如下的一种情形那么他就是可见进程。
　　a、 这个进程里一个Activity，但是这个Activity当前不是在前台显示，但是仍然对用户是可见的(这个Activity的onPause()方法被调用)，比如说一个Activity调用一个dialog，那么这个dialog是当前显示的组件，这个Activity不是在前台显示，但是对用户是可见的。
　　b、 这个进程里有一个绑定到一个可见Activity(如上所述的Activity)的service
　　一个可见进程是极端重要的，只有在为了显示所有前台进程时，即显示前台进程都不够时，才会停止可见进程。
　　(3)、服务进程。一个服务进程是一个通过startService()启动的但是没有在前两个分类中的进程，虽然服务进程不是用户直接能看见的，但是他也总是做一些用户很关心的事(如在后台播放mp3，从网络上下载东西)，所以系统会一直保持服务进程运行，除非内存不足以运行服务进程，前台进程，可见进程。
　　(4)后台进程。一个后台进程是运行一个当前对用户是不可见的Activity(这个Activity的onStop()被调用)，这些进程对用户体验没有什么直接的影响，当内存不足以运行前台进程，可见进程，服务进程时，可以随时停止后台进程，通常有很多的后台进程在运行，系统会把这些后台进程放进一个LRU中(最近使用队列)，最近使用的就最后停止。
　　(5)空进程。一个空进程就是进程里没有任何活动的应用组件，维持这种进程的唯一原因就是作为一种缓存，当一个组件需要启动时加快启动的速度，系统为了平衡进程缓存和核心缓存会停止这些空的进程。
　　Android系统会取一个进程里的所以组件的最高重要性来安排进程的重要性，比如说，一个进程里有一个service和一个可见的Activity，那么这个进程会被安排成一个可见进程，而不是服务进程。
　　另外，一个进程的重要性有可能会因为其他进程的依赖而升高，一个进程不能比他所服务的进程的重要性低，比如有进程A里的service绑定到了进程B的组件上，那么进程A的重要性至少和进程B的一样，或者更高。
　　因为一个服务进程的重要性比运行一个后台Activity的进程高，所以，当一个Activity做一些长时间运行的任务时，最好启动一个service来做，而不是放到一个线程里去做，特别是这个任务的时间可能比Activity运行的时间还长的时候，比如在后台播放音乐，或者上传一张图片到网上，使用一个service保证了这个任务至少是服务进程的重要性，broadcast receiver也是一样，长时间运行的任务也最好是放到一个service里，而不是放到一个线程里。

标签: android

进程和线程
当一个应用程序开始运行它的第一个组件时，Android会为它启动一个Linux进程，并在其中执行一个单一的线程。默认情况下，应用程序所有的组件均在这个进程的这个线程中运行。
然而，你也可以安排组件在其他进程中运行，而且可以为任意进程衍生出其它线程。
进程
组件运行所在的进程由manifest文件所控制。组件元素——<activity>， <service>， <receiver>和<provider>——都有一个 process 属性来指定组件应当运行于哪个进程之内。这些属性可以设置为使每个组件运行于它自己的进程之内，或一些组件共享一个进程而其余的组件不这么做。它们也可以设置为令不同应用程序的组件在一个进程中运行——使应用程序的组成部分共享同一个Linux用户ID并赋以同样的权限。<application>元素也有一个process属性，以设定所有组件的默认值。
所有的组件实例都位于特定进程的主线程内，而对这些组件的系统调用也将由那个线程进行分发。一般不会为每个实例创建线程 。因此，某些方法总是运行在进程的主线程内，这些方法包括诸如View.onKeyDown()这样报告用户动作以及后面 组件生命周期一节所要讨论的生命周期通告的。这意味着组件在被系统调用的时候，不应该施行长时间的抑或阻塞的操作（诸如网络相关操作或是循环计算），因为这将阻塞同样位于这个进程的其它组件的运行。你应该如同下面线程一节所叙述的那样，为这些长时间操作衍生出一个单独的线程进行处理。
在可用内存不足而又有一个正在为用户进行服务的进程需要更多内存的时候，Android有时候可能会关闭一个进程。而在这个进程中运行着的应用程序也因此被销毁。当再次出现需要它们进行处理的工作的时候，会为这些组件重新创建进程。
在决定结束哪个进程的时候，Android会衡量它们对于用户的相对重要性。比如说，相对于一个仍有用户可见的activity的进程，它更有可能去关闭一个其activity已经不为用户所见的进程。也可以说，决定是否关闭一个进程主要依据在那个进程中运行的组件的状态。这些状态将在后续的一节组件生命周期中予以说明。
线程
尽管你可以把你的应用程序限制于一个单独的进程中，有时，你仍然需要衍生出一个线程以处理后台任务。因为用户界面必须非常及时的对用户操作做出响应，所以，控管activity的线程不应用于处理一些诸如网络下载之类的耗时操作。所有不能在瞬间完成的任务都应安排到不同的线程中去。
线程在代码中是以标准Java Thread对象创建的。Android提供了很多便于管理线程的类： Looper用于在一个线程中运行一个消息循环， Handler用于处理消息，HandlerThread 用于使用一个消息循环启用一个线程。
远程过程调用
Android有一个轻量级的远程过程调用（RPC）机制：即在本地调用一个方法，但在远程（其它的进程中）进行处理，然后将结果返回调用者。这将方法调用及其附属的数据以系统可以理解的方式进行分离，并将其从本地进程和本地地址空间传送至远程过程和远程地址空间，并在那里重新装配并对调用做出反应。返回的结果将以相反的方向进行传递。Android提供了完成这些工作所需的所有的代码，以使你可以集中精力来实现RPC接口本身。
RPC接口可以只包括方法。即便没有返回值，所有方法仍以同步的方式执行（本地方法阻塞直至远程方法结束）。
简单的说，这套机制是这样工作的：一开始，你用简单的IDL（界面描绘语言）声明一个你想要实现的RPC接口。然后用 aidl 工具为这个声明生成一个Java接口定义，这个定义必须对本地和远程进程都可见。它包含两个内部类，
内部类中有管理实现了你用IDL声明的接口的远程方法调用所需要的所有代码。两个内部类均实现了 IBinder接口。一个用于系统在本地内部使用，你些的代码可以忽略它；另外一个，我们称为Stub，扩展了Binder类。除了实现了IPC调用的内部代码之外，它还包括了你声明的RPC接口中的方法的声明。你应该如上图所示的那样写一个Stub的子类来实现这些方法。
一般情况下，远程过程是被一个服务所管理的（因为服务可以通知系统关于进程以及它连接到别的进程的信息）。它包含着 aidl工具产生的接口文件和实现了RPC方法的Stub的子类。而客户端只需要包括aidl工具产生的接口文件。
下面将说明服务与其客户端之间的连接是如何建立的：
服务的客户端（位于本地）应该实现 onServiceConnected() 和 onServiceDisconnected() 方法。这样，当至远程服务的连接成功建立或者断开的时候，它们会收到通知。这样它们就可以调用 bindService() 来设置连接。
而服务则应该实现 onBind() 方法以接受或拒绝连接。这取决于它收到的intent（intent将传递给bindService()）。如果接受了连接，它会返回一个Stub的子类的实例。
如果服务接受了连接，Android将会调用客户端的onServiceConnected() 方法，并传递给它一个IBinder对象，它是由服务所管理的Stub的子类的代理。通过这个代理，客户端可以对远程服务进行调用。
线程安全方法
在一些情况下，你所实现的方法有可能会被多于一个的线程所调用，所以它们必须被写成线程安全的。
对于我们上一节所讨论的RPC机制中的可以被远程调用的方法来说，这是必须首先考虑的。如果针对一个IBinder对象中实现的方法的调用源自这个IBinder对象所在的进程时，这个方法将会在调用者的线程中执行。然而，如果这个调用源自其它的进程，则这个方法将会在一个线程池中选出的线程中运行，这个线程池由Android加以管理，并与IBinder存在于同一进程内；这个方法不会在进程的主线程内执行。反过来说，一个服务的 onBind() 方法应为服务进程的主线程所调用，而实现了由 onBind() 返回的对象（比如说，一个实现了RPC方法的Stub的子类）的方法将为池中的线程所调用。因为服务可以拥有多于一个的客户端，而同一时间，也会有多个池中的线程调用同一个IBinder方法。因此IBinder方法必须实现为线程安全的。
类似的，一个内容提供者能接受源自其它进程的请求数据。尽管ContentResolver和ContentProvider类隐藏了交互沟通过程的管理细节，ContentProvider会由query()， insert()， delete()， update()和getType()方法来相应这些请求，而这些方法也都是由那个内容提供者的进程中所包涵的线程池提供的，而不是进程的主线程本身。所以这些有可能在同一时间被很多线程调用的方法也必须被实现为线程安全的。

标签: android

1、需要申请的权限
android.permission.ACCESS_WIFI_STATE
android.permission.CHANGE_WIFI_STATE
android.permission.WAKE_LOCK

2、获取WifiManager
wifiManager = (WifiManager) this.getSystemService(Context.WIFI_SERVICE); 

3、开启、关闭wifi
if (wifiManager.isWifiEnabled()) { 
wifiManager.setWifiEnabled(false); 
} else { 
wifiManager.setWifiEnabled(true); 
}

标签: android