編輯：關於Android編程
綜述
在Android中，我們需要進行一些耗時的操作，會將這個操作放在子線程中進行。在子線程操作完成以後我們可以通過Handler進行發送消息，通知UI進行一些更新操作（具體使用及其原理可以查看Android的消息機制——Handler的工作過程這篇文章）。當然為了簡化我們的操作，在Android1.5以後為我們提供了AsyncTask類，它能夠將子線程處理完成後的結果返回到UI線程中，之後我們便可以根據這些結果進行一列的UI操作了。
AsyncTask的使用方法
實際上AsyncTask內部也就是對Handler和線程池進行了一次封裝。它是一個輕量級的異步任務類，它的後台任務在線程池中進行。之後我們可以將任務執行的結果傳遞給主線程，這時候我們就可以在主線程中操作UI了。
AsyncTask他是一個抽象的泛型類，所以我們創建一個子類，來實現AsyncTask中的抽象方法。AsyncTask中提供了三個泛型參數，下面我們就來看一下這三個泛型參數.
1. Params:在執行AsyncTask時所傳遞的參數，該參數在後台線程中使用。
2. Progress:後台任務執行進度的類型
3. Result:後台任務執行完成後返回的結果類型。
對於以上三個泛型參數我們不需要使用的時候，可以使用Void來代替。與Activity生命周期類似，在AsyncTask中也為我們提供了一些方法，我們通過重寫這幾個方法來完成整個異步任務。我們主要使用的方法有一下四個:
1. onPreExecute():該方法在異步任務工作之前執行，主要用於一些參數或者UI的初始化操作。
2. doInBackground(Params… params):該方法在線程池中執行，params參數表示異步任務時輸入的參數。在這個方法中我們通過publishProgress來通知任務進度。
3. onProgressUpdate(Progress… values):當後台任務的進度發生改變的時候會調用該方法，我們可以再這個方法中進行UI的進度展示。values參數表示任務進度。
4. postResult(Result result):在異步任務完成之後執行，result參數為異步任務執行完以後所返回的結果。
在上面四個方法中只有doInBackground在子線程中運行，其余都三個方法都是在主線程中運行的。其中的…表示參數的數量不定，是一種數組類型的參數。
下面我們就來寫一個例子來看一下AsyncTask的用法，在這裡我們就一個下載的功能，從網絡上下載兩個文件。我們先來看一下效果演示。
效果演示
代碼分析
由於我們做的下載任務，首先我們就得添加訪問網絡權限以及一些sd卡相關的權限。
<!-- 在SD卡中創建與刪除文件權限 --> <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/> <!-- 向SD卡寫入數據權限 --> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> <!-- 授權訪問網絡 --> <uses-permission android:name="android.permission.INTERNET"/>
下面我們來看一下Activity代碼。
package com.example.ljd.asynctask;
import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
private DownloadAsyncTask mDownloadAsyncTask;
private Button mButton;
private String[] path = {
"http://msoftdl.360.cn/mobilesafe/shouji360/360safesis/360MobileSafe_6.2.3.1060.apk",
"http://dlsw.baidu.com/sw-search-sp/soft/7b/33461/freeime.1406862029.exe",
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mButton = (Button)findViewById(R.id.button);
mButton.setOnClickListener(this);
}
@Override
protected void onDestroy() {
if (mDownloadAsyncTask != null){
mDownloadAsyncTask.cancel(true);
}
super.onDestroy();
}
@Override
public void onClick(View v) {
mDownloadAsyncTask = new DownloadAsyncTask();
mDownloadAsyncTask.execute(path);
}
class DownloadAsyncTask extends AsyncTask<String,Integer,Boolean>{
private ProgressDialog mPBar;
private int fileSize; //下載的文件大小
@Override
protected void onPreExecute() {
super.onPreExecute();
mPBar = new ProgressDialog(MainActivity.this);
mPBar.setProgressNumberFormat("%1d KB/%2d KB");
mPBar.setTitle("下載");
mPBar.setMessage("正在下載，請稍後...");
mPBar.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
mPBar.setCancelable(false);
mPBar.show();
}
@Override
protected Boolean doInBackground(String... params) {
//下載圖片
for (int i=0;i<params.length;i++){
try{
if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
URL url = new URL(params[i]);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
//設置超時時間
conn.setConnectTimeout(5000);
//獲取下載文件的大小
fileSize = conn.getContentLength();
InputStream is = conn.getInputStream();
//獲取文件名稱
String fileName = path[i].substring(path[i].lastIndexOf("/") + 1);
File file = new File(Environment.getExternalStorageDirectory(), fileName);
FileOutputStream fos = new FileOutputStream(file);
BufferedInputStream bis = new BufferedInputStream(is);
byte[] buffer = new byte[1024];
int len ;
int total = 0;
while((len =bis.read(buffer))!=-1){
fos.write(buffer, 0, len);
total += len;
publishProgress(total);
fos.flush();
}
fos.close();
bis.close();
is.close();
}
else{
return false;
}
}catch (IOException e){
e.printStackTrace();
return false;
}
}
return true;
}
@Override
protected void onPostExecute(Boolean aBoolean) {
super.onPostExecute(aBoolean);
mPBar.dismiss();
if (aBoolean){
Toast.makeText(MainActivity.this,"下載完成",Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(MainActivity.this,"下載失敗",Toast.LENGTH_SHORT).show();
}
}
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
mPBar.setMax(fileSize / 1024);
mPBar.setProgress(values[0]/1024);
}
}
}
在以上代碼中有幾點我們需要注意一下。
1. AsyncTask中的execute方法必須在主線程中執行。
2. 每個AsyncTask對象只能執行一次execute方法。
3. 當我們的Activity銷毀的時候需要進行取消操作，其中boolean型的參數mayInterruptIfRunning表示是否中斷後台任務。
最後的布局代碼就很簡單了，只有一個Button而已。
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="@dimen/activity_vertical_margin"
android:orientation="vertical"
tools:context="com.example.ljd.asynctask.MainActivity">
<Button
android:id="@+id/button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="download"/>
</LinearLayout>
這裡還有一點需要說明一下，由於在不同的Android版本中對AsyncTask進行了多次修改，所以當我們通過多個AsyncTask對象執行多次execute方法的時候，它們執行順序是串行還是並行根據系統不同的版本而出現差異，這裡就不再具體分析。
AsyncTask源碼分析
在這裡我們采用Android6.0中的AsyncTask源碼進行分析，對於不同系統的AsyncTask代碼會有一定的差異。當創建一個AsyncTask對象以後我們便可以通過execute方法來執行整個任務。那就在這裡首先看一下execute方法中的代碼。
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
可以看到這個execute方法中的代碼是如此的簡單，只是執行了executeOnExecutor方法並返回AsyncTask對象。下面我們就來看一下executeOnExecutor這個方法。
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
在這個方法內我們首先對AsyncTask所執行的狀態進行判斷。如果AsyncTask正在執行任務或者任務已經知己完成就會給我們拋出異常，也就解釋上面所說的每個AsyncTask對象只能執行一次execute方法。緊接著將當前任務狀態修改為正在運行以後便開始執行onPreExecute方法。這也說明了在上面我們重寫的四個方法中onPreExecute方法最先指向的。下面我們在看一下mWorker和mFuture這兩個全局變量。
mFuture是FutureTask對象，而mWorker是WorkerRunnable對象，WorkerRunnable是AsyncTask中的一個實現Callable接口的抽象內部類，在WorkerRunnable中只定義了一個Params[]。
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
......
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
mFuture和mWorker是在AsyncTask的構造方法中初始化的。我們看一下AsyncTask的構造方法。
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
在這裡首先創建一個WorkerRunnable對象mWorker，並且實現了Callable接口的call方法，對於這個call方面裡面的內容在後面會進行詳細說明。然後我們再通過mWorker，創建一個FutureTask對象mFuture，並且重寫裡面的done方法，當我們調用AsyncTask裡面的cancel方法時，在FutureTask中會調用這個done方法。在這裡介紹完mWorker和mFuture後我們再回過頭來看executeOnExecutor方法。在這裡通過我們傳入的params參數初始化了mWorker中的mParams。而下面的exec則是在execute裡面傳入的sDefaultExecutor，並且執行sDefaultExecutor的execute方法。下面我們再來看一下這個sDefaultExecutor對象。
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
......
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
......
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
在這裡首先整體介紹一下這段代碼。這段代碼的主要功能就是創建了兩個線程池SerialExecutor和THREAD_POOL_EXECUTOR。SerialExecutor線程池用於對任務的排隊，而THREAD_POOL_EXECUTOR則是用來執行任務。而sDefaultExecutor就是SerialExecutor線程池。
我們進入SerialExecutor代碼中看一下裡面的內容。SerialExecutor中的execute方法內的參數Runnable就是我們傳入的mFuture。在execute方法中創建了一個Runnable對象，並將該隊列插入對象尾部。這個時候如果是第一次執行任務。mActive必然為null，這時候便調用scheduleNext方法從隊列中取出Runnable對象，並且通過THREAD_POOL_EXECUTOR線程池執行任務。我們可以看到在隊列中的Runnable的run方法中首先執行mFuture中的run方法，執行完之後又會調用scheduleNext方法，從隊列中取出Runnable執行，直到所有的Runnable執行完為止。下面就來看一下在線城池中是如何執行這個Runnable的。從上面代碼可以看出，在線城池中執行Runnable其實最核心的部分還是執行mFuture的run方法。那就來看一下這個mFuture中的run方法。
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
在這個方法中的callable對象就是我們AsyncTask中的mWorker對象。在這裡面也正是執行mWorker中的call方法來完成一些耗時任務，於是我們就能想到我重寫的doInBackground應該就在這個call方法中執行了。現在再回到AsyncTask的構造方法中看一下這個mWorker中的call方法。
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
這裡我們很清楚的看到它執行我們重寫的doInBackground方法，並且將返回的結果傳到postResult方法中。下面就在看一下這個postResult方法。
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
對與這個postResult方法裡面也就是在我們子線程的任務處理完成之後通過一個Handler對象將Message發送到主線程中，並且交由主線程處理。AsyncTaskResult對象中存放的是子線程返回的結果以及當前AsyncTask對象。下面再看一下這和Handler中所處理了哪些事情。
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
可以看到在這個Handler的handleMessage中會接受到兩種Message。在MESSAGE_POST_PROGRESS這個消息中主要是通過publishProgress方法將子線程執行的進度發送到主線程中並且通過onProgressUpdate方法來更新進度條的顯示。在MESSAGE_POST_RESULT這個消息中通過當前的AsyncTask對象調用了finish方法，那麼就來看一下這個finish方法。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
這時候就可以看出若是我們取消了AsyncTask的話就不在執行onPostExecute方法，而是執行onCancelled方法，所以我們可以通過重寫onCancelled方法來執行取消時我們需要處理的一些操作。當然若是AsyncTask沒有被取消，這時候就回執行onPostExecute方法。到這裡整個AsyncTask任務也就完成了。
總結
在上面的SerialExecutor線程池中可以看出，當有多個異步任務同時執行的時候，它們執行的順序是串行的，會按照任務創建的先後順序進行一次執行。如果我們希望多個任務並發執行則可以通過AsyncTask中的setDefaultExecutor方法將線程池設為THREAD_POOL_EXECUTOR即可。
對於AsyncTask的在不同版本之間的差異不得不提一下。在Android1.6，AsyncTask采用的是串行執行任務，在Android1.6的時候采用線程池處理並行任務，而在3.0以後才通過SerialExecutor線程池串行處理任務。在Android4.1之前AsyncTask類必須在主線程中，但是在之後的版本中就被系統自動完成。而在Android5.0的版本中會在ActivityThread的main方法中執行AsyncTask的init方法，而在Android6.0中又將init方法刪除。所以在使用這個AsyncTask的時候若是適配更多的系統的版本的話，使用的時候就要注意了。
源碼下載：https://github.com/lijiangdong/asynctask-example
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持本站。
android底部彈出iOS7風格對話選項框(QQ對話框)--第三方開源之IOS_Dialog_Library
先給大家展示下效果圖，喜歡的朋友可以下載源碼哦。完成這個效果的是使用了 IOS_Dialog_Library下載地址：http://xiazai.jb51.net/201
解析Android聲明和使用權限
Android定義了一種權限方案來保護設備上的資源和功能。例如，在默認情況下，應用程序無法訪問聯系人列表、撥打電話等。下面就以撥打電話為例介紹一下系統對權限的要求。一般在
UI組件之ImageView及其子類（一）ImageView顯示圖片
ImageView家族的繼承關系如圖：ImageView繼承自View組件，它的主要功能室顯示圖片，還可以顯示Drawable對象。ImageView直接子類是Image
Android圖片選擇器 豐富的配置選項
最近也是剛好項目用到，於是就動手寫了一個Android 圖片選擇器的庫。支持圖庫多選/單選/圖片裁剪/拍照/自定義圖片加載庫，極大程度的簡化使用。截圖優點1、通過實現Im
