asynctask怎么读,android：如何实现点击按钮，弹出“正在加载数据，请稍候...”对话框，加载完了之后，对话框自动

asynctask怎么读,android：如何实现点击按钮，弹出“正在加载数据，请稍候...”对话框，加载完了之后，对话框自动详细介绍

本文目录一览： async读音

async读音为：[?'z??k]
提升口语的方法：
1、关键的词汇
这样的单词最少有2000个，你认为2000很多吗？事实上，最基本的介词、名词和动词已经占了近1000个单词，所以这些单词只能确保你具备初步交流的能力。如果话题再进一步，你就无法理解了。
2、基本的交流词汇
基础交际需要3000 - 4000个单词的词汇量，相当于通过大学英语六级考试的学员的词汇量。一般来说，词汇量大的学员可以清晰地表达自己的观点，在日常交流中不会有大的问题。
3、精通沟通词汇
学习英语口语过程中，如果想要流利准确的表达自己的观点，需要储备大约6000 - 7000个单词。如果你有这么大的词汇量，但仍然不能顺畅地交流，那一定是由于日常练习太少或练习方法不对。
4、每天大声朗读
大声朗读对学习英语口语很有帮助，为了在日常交流中保持流畅，你需要先流利地朗读。每天花30-40分钟，选择一篇你感兴趣的文章来阅读，我相信它会无形中培养你的语感。

ASYnctask.dll是什么意思，电脑显示计算机中丢失这个。怎么办

某个软件的一个动态库文件。
显示丢失，那么可以通过重新安装对应的软件即可修复。
　　通过重新安装对应的软件即可修复。
msvcrtd.dll是微软VC++编译程序调试版本相关的文件，如果你的电脑不涉及到VC++编程方面的应用，而系统弹出这个提示的话，建议你先对电脑进行查毒，确认没有病毒及木马程序后，可以到网上搜索MSVCRTD.dll，下载后如果是Windows XP系统，复制到C:\Windows\System32目录下。之后在开始-》运行中输入regsvr32 msvcrtd.dll。注册一下这个DLL文件就可以了
追问：
我是win7系统的？？
回答：
win7系统复制到c:\windows下就可以了

为什么在doInbackground更新UI线程会遇到错误

1. 我所理解迄今为止，Android是......， 我们不能从更新后台线程UI线程。 可能是他们必须从更新后台线程的UI的情况下。 其中的原因是很清楚...@OS级别会有这么多的线程将运行。 并且还 从不同的应用不同的线程，而在这种情况下，这将是混乱的屏幕上，如果我们能够从BG-线程更新用户界面
2. 所以你必须只在OnPostExecute＆OnPreExecute更新UI。 这里的AsyncTask的一个很好的例子。试试看 您可以通过调用它
new SaveProfile().execute();
那么这...
private class SaveProfile extends AsyncTask

{

@Override

protected Boolean doInBackground(String... params) {

//---------- so your stuff here.... non ui related

Log.v("response from saving",response);

if(response.equals("1")){

return true;

}else{

return false;

}

}

protected void onPostExecute(Boolean result) {

if(result) {

//------ UPDATE UI HERE

Toast.makeText(ProfileCompanyActivity.this, "profile saved", 2500).show();

}else{

Toast.makeText(ProfileCompanyActivity.this, "an error occured", 2500).show();

}

}

}

3. 里面的doInBackgroundyou不会得到用户界面的访问。如果你想利用UI访问publishProgress从doInBackgroundyou会去onProgressUpdate从那里做什么，你婉显示在UI上。 下面是代码 CodeGo.net，您将检查供您参考： 类DownloadAsyncTask扩展的AsyncTask {

ProgressDialog progressDialog;

@Override

protected void onPreExecute() {

super.onPreExecute();

progressDialog = ProgressDialog.show(Login.this, "", "Please Wait ...");

}

@Override

protected Void doInBackground(String... arg0) {

int status1 = validationuser(username);

Log.i("MyLog", "Inside the doInBackground is came"+status1);

if(status1 == 1)

{

publishProgress(status1+ "Valid User Code","1",""+status1);

}

else

{

publishProgress(status1+ " Invalid Valid User Code","0",""+status1);

}

return null;

}

@Override

protected void onProgressUpdate(String...values){

super.onProgressUpdate(values);

int index = Integer.parseInt(values[2]);

if(index == 1)

{

USERIDLOGIN = edittextuserName.getText().toString();

Intent intent=new Intent(Login.this, CollectionModuleandDownload.class);

/*Toast.makeText(Login.this, "Valid User Password", Toast.LENGTH_SHORT).show();*/

startActivity(intent);

progressDialog.dismiss();

}

else

{

Toast.makeText(Login.this, "Invalid Username & Password", Toast.LENGTH_SHORT).show();

progressDialog.dismiss();

}

}

@Override

protected void onPostExecute(Void result){

super.onPostExecute(result);

/*if(progressDialog != null)

{

progressDialog.dismiss();

}*/

}

}

4. 当你创建一个Aysnc任务doInBackground方法运行在从UI线程的单独的线程。所以你不能从更新UI 该OnPostExecute和onPreExecute方法在线程作为UI线程中执行。进一步阅读到这里

5. 如果只允许一个线程去触摸界面，Android的可以保证，没有什么重要的改变，而它的views，并将其绘制到屏幕 这是..用户界面只能在当您尝试从另一个线程改变接口（做背景），在这种情况下被更新mainthread ..在你的屏幕上所有的接口对象由本mainthread维护....现在..它的错误例子..如果您尝试从非主线程其它改变seekbar（窗口小部件）价值。并试图把不同的值......那么它是Android ..因为它应该听哪个线程...希望澄清你的疑问.. 因此，它是像我们should'nt尝试..和它的安全性..我们不能尝试也。因为它给错误..=]

6. doInBackground执行繁重的计算或者你想在你的活动执行任何后台工作。 当在操作的完成上upadates你的UI .. 总之doinbackground是更新UI。

7. 我想答案是，我们绝不能 它只是看起来不合乎逻辑 它像试图改变电台在另一辆自动行驶在你身边.. 该架构是行不通的呀..您可以在电台上决定你之前设置给您的客场之旅，或当你停止驾驶，理论上你可以喊他，并要求他改变站，但你不能做自己。

8. 由于doInBackground（）运行在独立的线程和onPostExecute运行在UIMain线程和每个Android提供constraints你不能更新从其他线程UIMain主题。 原因你是消息，而你正在运行的应用程序。

android：如何实现点击按钮，弹出“正在加载数据，请稍候...”对话框，加载完了之后，对话框自动

实现过程其实很简单。
第一步：自定义一个WaitingDialog，该Dialog支持自定义文本，一个可转动的图片，也可以增加一个定时关闭的接口，当然也可以选择外部定时关闭。
第二步：在页面调用。
如果我仅仅是这么回答，你可能觉得我在敷衍你，可是我为你的问题写了一个DEMO，你可以直接去下载，在CSDN上，就不知道百度有没有这么开放了，哈哈。
地址：http://download.csdn.net/download/yanjunhui2011/10019463

Android中的Handler和AsyncTask的区别

Android平台很多应用使用的都是AsyncTask，而并非Thread和Handler去更新UI，这里Android123给大家说下他们到底有什么区别，我们平时应该使用哪种解决方案。从Android 1.5开始系统将AsyncTask引入到android.os包中，过去在很早1.1和1.0 SDK时其实官方将其命名为UserTask，其内部是jdk 1.5开始新增的concurrent库，做过j2ee的网友可能明白并发库效率和强大性，比Java原始的Thread更灵活和强大，但对于轻量级的使用更为占用系统资源。Thread是Java早期为实现多线程而设计的，比较简单不支持concurrent中很多特性在同步和线程池类中需要自己去实现很多的东西，对于分布式应用来说更需要自己写调度代码，而为了Android UI的刷新google引入了Handler和Looper机制，它们均基于消息实现，有事可能消息队列阻塞或其他原因无法准确的使用。 Android开发网推荐大家使用AsyncTask代替Thread+Handler的方式，不仅调用上更为简单，经过实测更可靠一些，Google在Browser中大量使用了异步任务作为处理耗时的I/O操作，比如下载文件、读写数据库等等，它们在本质上都离不开消息，但是 AsyncTask相比Thread加Handler更为可靠，更易于维护，但AsyncTask缺点也是有的比如一旦线程开启即 dobackground方法执行后无法给线程发送消息，仅能通过预先设置好的标记来控制逻辑，当然可以通过线程的挂起等待标志位的改变来通讯，对于某些应用Thread和Handler以及Looper可能更灵活。

android AsyncTask 怎么返回值给UI线程

可以看下以下几点即可：
1.把AsyncTask单独写成类，不是其他Activity的子类。（这个显然可以，记住，虽然AsyncTask不是某个Activity的子类，它依然只能在主线程中创建，其四大方法中的三个依然运行在主线程中，详情见后面。）2.UI线程 通过AsyncTask和服务器交互，需要根据结果 打开不同的新的activity，可以onPostExecute() 中返回值给主线程吗？（这个问句就是错的，onPostExecute()就是在主线程中执行的，不需要返回值给主线程，只需要在此方法中将结果存储在某个变量中，就可以在主线程中获取此值。例如，在AsyncTask中增加一个getResult方法）3.另外一个问题， 可以传参数给AsyncTask，然后在onPostExecute 使用其他activity的 finish() 吗？（Yes of course。这句问话依然来自你对onPostExecute 的误解，再说一次，它就在主线程中执行。而Activity的finish方法在主线程中调用显然没问题。）简单说AsyncTask，正好把上一个回答的部分结果拷贝过来给参考：
AsyncTask是一个辅助类，就是为了将Handler、Thread等封装为一个异步执行框架，供Android Coder可以方便的使用。其主要目的是为了“在其他线程中执行一个耗时操作，并随时报告执行进度给UI线程，执行完成后将结果报告给UI线程”。
AsyncTask的使用方法其实Android developer中已经说得非常清楚了，因此择重点翻译一次：
AsyncTask使用时必须作为基类被扩展，子类至少重载一个方法doInBackground，另一个方法onPostExecute也经常被重载，代码例子如下：
6private class DownloadFilesTask extends AsyncTask

{

protected Long doInBackground(URL... urls) {

int count = urls.length;

long totalSize = 0;

for (int i = 0; i < count; i++) {

totalSize += Downloader.downloadFile(urls[i]);

publishProgress((int) ((i / (float) count) * 100));

// Escape early if cancel() is called

if (isCancelled()) break;

}

return totalSize;

}

protected void onProgressUpdate(Integer... progress) {

setProgressPercent(progress[0]);

}

protected void onPostExecute(Long result) {

showDialog("Downloaded " + result + " bytes");

}

}

AsyncTask含有三个泛型参数： Params, 异步任务执行所需的参数类型； Progress, 异步任务执行进度的类型； Result, 异步任务执行结果的类型。 这三个参数不必全部使用，不使用的参数置为Void即可，例如:

private class MyTask extends AsyncTask

{ ... }

AsyncTask的四个重要方法。当一个异步任务被执行时，要经历四步： onPreExecute(),在UI线程中执行，它会在异步任务开始前执行，一般用来设置任务参数； doInBackground, 最重要的方法，在子线程中执行（事实上，只有它在子线程中执行，其他方法都在UI线程中执行）。当onPreExecute结束后，本方法立刻执行，它用来进行后台的耗时计算，异步任务的参数会被传给它，执行完成的结果会被送给第四步；执行途中，它还可以调用publishProgress 方法来通知UI线程当前执行的进度； onProgressUpdate, 当publishProgress 被调用后，它在UI线程中执行，刷新任务进度，一般用来刷新进度条等UI部件； onPostExecute, 当后台的异步任务完成后，会在UI线程中被调用，并获取异步任务执行完成的结果。

android 大量多线程怎么优化

在程序开发的实践当中，为了让程序表现得更加流畅，我们肯定会需要使用到多线程来提升程序的并发执行性能。但是编写多线程并发的代码一直以来都是一个相对棘手的问题，所以想要获得更佳的程序性能，我们非常有必要掌握多线程并发编程的基础技能。
众所周知，Android 程序的大多数代码操作都必须执行在主线程，例如系统事件(例如设备屏幕发生旋转)，输入事件(例如用户点击滑动等)，程序回调服务，UI 绘制以及闹钟事件等等。那么我们在上述事件或者方法中插入的代码也将执行在主线程。
一旦我们在主线程里面添加了操作复杂的代码，这些代码就很可能阻碍主线程去响应点击/滑动事件，阻碍主线程的 UI 绘制等等。我们知道，为了让屏幕的刷新帧率达到 60fps，我们需要确保 16ms 内完成单次刷新的操作。一旦我们在主线程里面执行的任务过于繁重就可能导致接收到刷新信号的时候因为资源被占用而无法完成这次刷新操作，这样就会产生掉帧的现象，刷新帧率自然也就跟着下降了(一旦刷新帧率降到 20fps 左右，用户就可以明显感知到卡顿不流畅了)。
为了避免上面提到的掉帧问题，我们需要使用多线程的技术方案，把那些操作复杂的任务移动到其他线程当中执行，这样就不容易阻塞主线程的操作，也就减小了出现掉帧的可能性。
那么问题来了，为主线程减轻负的多线程方案有哪些呢？这些方案分别适合在什么场景下使用？Android 系统为我们提供了若干组工具类来帮助解决这个问题。
AsyncTask: 为 UI 线程与工作线程之间进行快速的切换提供一种简单便捷的机制。适用于当下立即需要启动，但是异步执行的生命周期短暂的使用场景。
HandlerThread: 为某些回调方法或者等待某些任务的执行设置一个专属的线程，并提供线程任务的调度机制。
ThreadPool: 把任务分解成不同的单元，分发到各个不同的线程上，进行同时并发处理。
IntentService: 适合于执行由 UI 触发的后台 Service 任务，并可以把后台任务执行的情况通过一定的机制反馈给 UI。
了解这些系统提供的多线程工具类分别适合在什么场景下，可以帮助我们选择合适的解决方案，避免出现不可预期的麻烦。虽然使用多线程可以提高程序的并发量，但是我们需要特别注意因为引入多线程而可能伴随而来的内存问题。举个例子，在 Activity 内部定义的一个 AsyncTask，它属于一个内部类，该类本身和外面的 Activity 是有引用关系的，如果 Activity 要销毁的时候，AsyncTask 还仍然在运行，这会导致 Activity 没有办法完全释放，从而引发内存泄漏。所以说，多线程是提升程序性能的有效手段之一，但是使用多线程却需要十分谨慎小心，如果不了解背后的执行机制以及使用的注意事项，很可能引起严重的问题。

Android进程间和线程间通信方式

? ? ? ? 进程：是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

??线程：是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一些在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

??区别：

??（1）、一个程序至少有一个进程，一个进程至少有一个线程；

??（2）、线程的划分尺度小于进程，使得多线程程序的并发性高；

??（3）、进程在执行过程中拥有独立的内存单元，而多个线程共享内存，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。

---------------------

一、Android进程间通信方式

1.Bundle

??由于Activity，Service，Receiver都是可以通过Intent来携带Bundle传输数据的，所以我们可以在一个进程中通过Intent将携带数据的Bundle发送到另一个进程的组件。

??缺点：无法传输Bundle不支持的数据类型。

2.ContentProvider

??ContentProvider是Android四大组件之一，以表格的方式来储存数据，提供给外界，即Content Provider可以跨进程访问其他应用程序中的数据。用法是继承ContentProvider，实现onCreate,query,update,insert,delete和getType方法，onCreate是负责创建时做一些初始化的工作，增删查改的方法就是对数据的查询和修改，getType是返回一个String，表示Uri请求的类型。注册完后就可以使用ContentResolver去请求指定的Uri。

3.文件

??两个进程可以到同一个文件去交换数据，我们不仅可以保存文本文件，还可以将对象持久化到文件，从另一个文件恢复。要注意的是，当并发读/写时可能会出现并发的问题。

4.Broadcast

??Broadcast可以向android系统中所有应用程序发送广播，而需要跨进程通讯的应用程序可以监听这些广播。

5.AIDL方式

??Service和Content Provider类似，也可以访问其他应用程序中的数据，Content Provider返回的是Cursor对象，而Service返回的是Java对象，这种可以跨进程通讯的服务叫AIDL服务。

? ? ? ? ?AIDL通过定义服务端暴露的接口，以提供给客户端来调用，AIDL使服务器可以并行处理，而Messenger封装了AIDL之后只能串行运行，所以Messenger一般用作消息传递。

6.Messenger

??Messenger是基于AIDL实现的，服务端（被动方）提供一个Service来处理客户端（主动方）连接，维护一个Handler来创建Messenger，在onBind时返回Messenger的binder。

??双方用Messenger来发送数据，用Handler来处理数据。Messenger处理数据依靠Handler，所以是串行的，也就是说，Handler接到多个message时，就要排队依次处理。

7.Socket

??Socket方法是通过网络来进行数据交换，注意的是要在子线程请求，不然会堵塞主线程。客户端和服务端建立连接之后即可不断传输数据，比较适合实时的数据传输

二、Android线程间通信方式

??一般说线程间通信主要是指主线程（也叫UI线程）和子线程之间的通信，主要有以下两种方式：

1.AsyncTask机制

??AsyncTask，异步任务，也就是说在UI线程运行的时候，可以在后台的执行一些异步的操作；AsyncTask可以很容易且正确地使用UI线程，AsyncTask允许进行后台操作，并在不显示使用工作线程或Handler机制的情况下，将结果反馈给UI线程。但是AsyncTask只能用于短时间的操作（最多几秒就应该结束的操作），如果需要长时间运行在后台，就不适合使用AsyncTask了，只能去使用Java提供的其他API来实现。

2.Handler机制

??Handler，继承自Object类，用来发送和处理Message对象或Runnable对象；Handler在创建时会与当前所在的线程的Looper对象相关联(如果当前线程的Looper为空或不存在，则会抛出异常，此时需要在线程中主动调用Looper.prepare()来创建一个Looper对象)。使用Handler的主要作用就是在后面的过程中发送和处理Message对象和让其他的线程完成某一个动作（如在工作线程中通过Handler对象发送一个Message对象，让UI线程进行UI的更新，然后UI线程就会在MessageQueue中得到这个Message对象（取出Message对象是由其相关联的Looper对象完成的），并作出相应的响应）。

三、Android两个子线程之间通信

??面试的过程中，有些面试官可能会问Android子线程之间的通信方式，由于绝大部分程序员主要关注的是Android主线程和子线程之间的通信，所以这个问题很容易让人懵逼。

??主线程和子线程之间的通信可以通过主线程中的handler把子线程中的message发给主线程中的looper，或者，主线程中的handler通过post向looper中发送一个runnable。但looper默认存在于main线程中，子线程中没有Looper，该怎么办呢？其实原理很简单，把looper绑定到子线程中，并且创建一个handler。在另一个线程中通过这个handler发送消息，就可以实现子线程之间的通信了。

??子线程创建handler的两种方式：

??方式一：给子线程创建Looper对象：

new Thread(new Runnable() {

? ? ? ? ? ? public void run() {?

? ? ? ? ? ? ? ? Looper.prepare();? // 给这个Thread创建Looper对象，一个Thead只有一个Looper对象

? ? ? ? ? ? ? ? Handler handler = new Handler(){?

? ? ? ? ? ? ? ? ? ? @Override?

? ? ? ? ? ? ? ? ? ? public void handleMessage(Message msg) {?

? ? ? ? ? ? ? ? ? ? ? ? Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();?

? ? ? ? ? ? ? ? ? ? }?

? ? ? ? ? ? ? ? };?

? ? ? ? ? ? ? ? handler.sendEmptyMessage(1);?

? ? ? ? ? ? ? ? Looper.loop(); // 不断遍历MessageQueue中是否有消息

? ? ? ? ? ? };?

? ? ? ? }).start();

---------------------

? ? ? ?方式二：获取主线程的looper，或者说是UI线程的looper：

new Thread(new Runnable() {

? ? ? ? ? ? public void run() {?

? ? ? ? ? ? ? ? Handler handler = new Handler(Looper.getMainLooper()){ // 区别在这！！！?

? ? ? ? ? ? ? ? ? ? @Override?

? ? ? ? ? ? ? ? ? ? public void handleMessage(Message msg) {?

? ? ? ? ? ? ? ? ? ? ? ? Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();?

? ? ? ? ? ? ? ? ? ? }?

? ? ? ? ? ? ? ? };?

? ? ? ? ? ? ? ? handler.sendEmptyMessage(1);?

? ? ? ? ? ? };?

? ? ? ? }).start();

---------------------

android底层网络框架是怎么实现的

一个好用的网络底层框架可以很大的程度上方便自己的项目，我们下面要做的就是一个趁手的网络框架。
做一个网络框架我们首先要确定这个网络框架除了能够从网络上获取数据还需要哪些功能：
首先抛弃AsyncTask，自定义一套网络底层的封装框架。
设计一套适合自己App的缓存策略
设计一套假数据返回的机制，在网络请求API没有返回的时候，可以假装获取到了网络返回的数据。
封装用户cookie的逻辑。
其他的还好，可能有人对于第一步的那个抛弃AsyncTask有些疑问，就是为什么要抛弃啊，这个类这个好用，内部封装了那么多的方法。但是我们不能只看到这个的优点，这个类有个致命的缺点：不能灵活的控制内部的线程池。
我们都知道的是，线程池里面的每个线程都是API的调用请求，而AsyncTask中有没有暴漏出取消这些请求的方法，这个时候，如果我们从A界面调到B界面，那么在A界面调用的API请求，如果还没有返回，并不会被取消，对于一个频繁调用API请求的APP应用应用来说，一个界面调用的API可能超过十个，在网络不好的情况下，如果这个时候跳转到了其他界面，这个时候其他界面也会调用API，这个时候造成的情况就是这个界面的请求并不会显示数据，因为首页的请求还在排队，要等首页的请求完成之后你才可以调用，这个就是所谓的AsyncTask堵塞。
我刚工作的时候遇到一个情况就是，根据公司的情况写了一个统计用户交互数据的SDK，开始的使用时候就是这个AsyncTask类，结构我发现在APP中某一个界面的吊起特别的慢，数据加载也非常的慢，发现的原因是我写的这个SDK中的API请求调用超时，并且在超时的时候重复调用三次这个API。
网络请求的格式
网络请求两个方法POST和GET，我们一般把GET方法为请求数据，POST为修改数据。请求的方法格式也是相对有讲究的。
Request
所有的MobileApi都可以写作：http：//www.xxx.com/aaaa.api的形式。
GET：对于GET方法我们可以将请求API写作http：//www.xxx.com/aaaa.api K1=va1&K2=va2，形式，也就是说，把key-value这样的键值对存放在URL上，这样做的话会方便我们后面对数据进行缓存，另外要精良是GET的参数都是String，int这样的类型，方便缓存，解析。
POST：我们都知道看不见POST的请求数据，一般key-value这样的键值对存放在Form表单中，最后进行提交请求。POST经常会提交大量数据，所以有些键值对要定义成集合或复杂的自定义实例，这个时候我们就需要把这样的值转换为JSON字符串进行提交，有APP传递到API后，在将JSON字符串转换为对于的实体。
Response
服务器现在用的最多的是使用JSON作为api返回的结果，这里也是使用JSON。
一般情况下返回的json数据中要有以下数据：
首先一个是否调用api成功的参数，
另外一个错误类型的参数(这个参数可以是Int格式的参数，成功为0)
错误具体信息的参数，成功为“”
具体API返回的结果，失败为“”
所以我们定义一个Response实体类，作为JSON实体的最外层。
如果成功返回了数据，数据会存放在result字符按中，映射为Response实体的result属性。
如果上面返回的result是一种实体的集合，那么就要把result解析为相应的实体集合。
我们在前面看到我们把AsyncTask抛弃重新写一个扩展性强的，可以随时取消API请求网络底层，那么我们的这个网络底层的线程池使用的是什么：使用原生的ThreadPoolExecutor + Runnable + Handler
首先我们要把App所调用的所有的API接口放到一个类或者xml文件中去，我们这里放在xml文件里面去，当然要写出读取xml的类和函数：
其中key和url的值符合key-value键值，expires代表数据缓存的时间单位为毫秒，netType代表请求方式(POST和GET) ，mockClass代表的是返回假数据的类。
RemoteService和RequestCallback和RequestParameter
这三个类表示的是请求的服务，请求返回，请求参数，三个给APP调用的类。
其他的两个类在方法中调用：
context：表示上下文
key：即xml文件中的key
RequestParameter：请求携带的参数
callback：请求回调
forceUpdate：是否强制更新数据，忽略缓存
RequestMannager类是一个集合类，用于取消请求的。每次发起请求时，都会把为此创建的Request添加到RequestManager中，即RequestManager中保存了全部的request。
他是对ThreadPoolExecutor和ArrayBlockingQueue的简单封装，是一个线程池，每发起一次请求，这个线程池就会分配一个新的线程来执行该请求。
HttpRequest类，发起HTTP请求的地方，他事先了Runable，从而让DefaultThreadPool可以分配新的线程，所以所有的请求逻辑都在Runnable接口方法里：
在这个类中对于get请求接口，他会把传递来的数据，处理为相应的格式：http：//www.xxx.com/aaaa.api K1=va1&K2=va2。对于Post格式的请求接口，他会把传递过来的数据转换为BasicNameValuePair的形式，并放在表单中提交。
需要注意的是，因为我们把每个HttpRequest都放在了子线程中执行，所以RequestCallback的回调不能直接操作UI线程的控件，所以这个时候Handler就可以用到了。使用这个就可以保证RequestCallback的回调在UI线程上，不会报错。

有哪些 Android 的开源界面库

一.认识android的架构
Android其本质就是在标准的Linux系统上增加了Java虚拟机Dalvik，并在Dalvik虚拟机上搭建了一个JAVA的application framework，所有的应用程序都是基于JAVA的application framework之上。
android分为四个层，从高层到低层分别是应用程序层、应用程序框架层、系统运行库层和linux核心层。
二.搭建环境
搭建开发环境
对国内的开发者来说最痛苦的是无法去访问android开发网站。为了更好的认识世界，对程序员来说，会翻墙也是的一门技术，带你去领略墙外的世界，好了，不废话了, 国内开发者访问(androiddevtools) 上面已经有了所有你要的资源，同时可以下载到我们的主角framework
但是这样的搭建只能去阅读源代码，我们无法去更进一步去实现自己的rom,我们看到锤子的系统在早期的开放rom是自己从新实现了framework的代码，现在看起来他成功了，所以我们还要去搭建android系统的源码编译环境。
搭建源码编译环境
三.开始主题
在一开始写c程序的时候都有一个运行的入口，比如
#include

#include

#include

using namespace std;

//这里的main就是应用的入口

int main(int argc, const char * argv[]){

return 0;

}

在计算机网络原理中我们用socket实现一个服务器端，不断的接听客户端的访问，而且他的代码是这样实现的：

#include

#pragma comment(lib, "WS2_32.lib")

#include

void main()

{

WORD wVersionRequested;//版本号

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字

//加载套接字库,如果失败返回

err = WSAStartup(wVersionRequested, &wsaData);

if (err != 0)

{

return;

}

//判断高低字节是不是2,如果不是2.2的版本则退出

if (LOBYTE(wsaData.wVersion) != 2 ||

HIBYTE(wsaData.wVersion) != 2)

{

return;

}

//创建流式套接字,基于TCP(SOCK_STREAM)

SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);

//Socket地址结构体的创建

SOCKADDR_IN addrSrv;

addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格

addrSrv.sin_family = AF_INET;//指定地址簇

addrSrv.sin_port = htons(6000);

//指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换

//将套接字绑定到一个端口号和本地地址上

bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行

listen(socSrv, 5);

SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体

int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof

//循环等待接受客户端发送请求

while (1)

{

//等待客户请求到来；当请求到来后，接受连接请求，

//返回一个新的对应于此次连接的套接字（accept）。

//此时程序在此发生阻塞

SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);

char sendBuf[100];

sprintf(sendBuf, "Welcome %s to JoyChou",

inet_ntoa(addrClient.sin_addr));//格式化输出

//用返回的套接字和客户端进行通信

send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节

//接收数据

char recvBuf[100];

recv(sockConn, recvBuf, 100, 0);

printf("%s\\n", recvBuf);

closesocket(sockConn);

}

}

他采用了一个while死循环去监听客户端的请求。

先上源代码

public final class ActivityThread {

public static void main(String[] args) {

SamplingProfilerIntegration.start();

CloseGuard.setEnabled(false);

Environment.initForCurrentUser();

EventLogger.setReporter(new EventLoggingReporter());

Security.addProvider(new AndroidKeyStoreProvider());

final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());

TrustedCertificateStore.setDefaultUserDirectory(configDir);

Process.setArgV0("

");

Looper.prepareMainLooper();

//从中可以看到为app开辟了一个线程进入了looper之中

ActivityThread thread = new ActivityThread();

thread.attach(false);

if (sMainThreadHandler == null) {

sMainThreadHandler = thread.getHandler();

}

AsyncTask.init();

if (false) {

Looper.myLooper().setMessageLogging(new

LogPrinter(Log.DEBUG, "ActivityThread"));

}

Looper.loop();

throw new RuntimeException("Main thread loop unexpectedly exited");

}

}

看到源码失望了，没有一个while循环啊，其实用了他方法实现

//用一个looper的机制循环监听响应

Looper.prepareMainLooper();

Looper.loop();

进一步深入代码

public static void loop() {

final Looper me = myLooper();

if (me == null) {

throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");

}

final MessageQueue queue = me.mQueue;

Binder.clearCallingIdentity();

final long ident = Binder.clearCallingIdentity();

// 在这里看到了一个循环监听消息

for (;;) {

Message msg = queue.next(); // might block

if (msg == null) {

// No message indicates that the message queue is quitting.

return;

}

Printer logging = me.mLogging;

if (logging != null) {

logging.println(">>>>> Dispatching to " + msg.target + " " +

msg.callback + ": " + msg.what);

}

msg.target.dispatchMessage(msg);

if (logging != null) {

logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);

}

// Make sure that during the course of dispatching the

// identity of the thread wasn't corrupted.

final long newIdent = Binder.clearCallingIdentity();

if (ident != newIdent) {

Log.wtf(TAG, "Thread identity changed from 0x"

+ Long.toHexString(ident) + " to 0x"

+ Long.toHexString(newIdent) + " while dispatching to "

+ msg.target.getClass().getName() + " "

+ msg.callback + " what=" + msg.what);

}

msg.recycleUnchecked();

}

}

安卓整个系统都是开源的

比较火爆的Android开源库有以下：

1、volley

主要有以下模块：

(1) JSON，图像等的异步下载；

(2) 网络请求的排序（scheduling）

(3) 网络请求的优先级处理

(4) 缓存

(5) 多级别取消请求

(6) 和Activity和生命周期的联动（Activity结束时同时取消所有网络请求）2、android-async-http

主要有以下模块：

(1) 在匿名回调中处理请求结果

(2) 在UI线程外进行

(3) 文件断点上传

(4) 智能重试

(5) 默认gzip压缩

(6) 支持解析成Json格式

(7) 可将Cookies持久化到SharedPreferences 3、Afinal框架

主要有四大模块：

(1) 数据库模块：android中的

，使用了线程池对sqlite进行操作。

(2) 注解模块：android中的ioc框架，完全注解方式就可以进行UI绑定和事件绑定。无需findViewById和setClickListener等。

(3) 网络模块：通过httpclient进行封装http数据请求，支持ajax方式加载，支持下载、上传文件功能。

(4) 图片缓存模块：通过FinalBitmap，imageview加载bitmap的时候无需考虑bitmap加载过程中出现的oom和android容器快速滑动时候出现的图片错位等现象。4、xUtils框架

主要有四大模块：

(1) 数据库模块：android中的

，一行代码就可以进行增删改查；

(2) 注解模块：android中的ioc框架，完全注解方式就可以进行UI，资源和事件绑定；

(3) 网络模块：支持同步，异步方式的请求；

(4) 图片缓存模块：加载bitmap的时候无需考虑bitmap加载过程中出现的oom和android容器快速滑动时候出现的图片错位等现象；5、ThinkAndroid主要有以下模块：(1) MVC模块：实现视图与模型的分离。

(2) ioc模块：android中的ioc模块，完全注解方式就可以进行UI绑定、res中的资源的读取、以及对象的初始化。

(3) 数据库模块：android中的

，使用了线程池对sqlite进行操作。

(4) http模块：通过httpclient进行封装http数据请求，支持异步及同步方式加载。

(5) 缓存模块：通过简单的配置及设计可以很好的实现缓存，对缓存可以随意的配置

(6) 图片缓存模块：imageview加载图片的时候无需考虑图片加载过程中出现的oom和android容器快速滑动时候出现的图片错位等现象。

(7) 配置器模块：可以对简易的实现配对配置的操作，目前配置文件可以支持Preference、Properties对配置进行存取。

(8) 日志打印模块：可以较快的轻易的是实现日志打印，支持日志打印的扩展，目前支持对sdcard写入本地打印、以及控制台打印

(9) 下载器模块:可以简单的实现

、后台下载、

、对下载进行控制、如开始、暂停、删除等等。

(10) 网络状态检测模块：当网络状态改变时，对其进行检6、LoonAndroid 主要有以下模块：

(1) 自动注入框架（只需要继承框架内的application既可）

(2) 图片加载框架（多重缓存，自动回收，最大限度保证内存的安全性）

(3) 网络请求模块（继承了基本上现在所有的

）

(4) eventbus（集成一个开源的框架）

(5) 验证框架（集成开源框架）

(6) json解析（支持解析成集合或者对象）

(7) 数据库（不知道是哪位写的 忘记了）

(8) 多线程断点下载（自动判断是否支持多线程，判断是否是重定向）

(9) 自动更新模块

(10) 一系列工具类