詳細講解AsyncTask使用說明(值得收藏)
概念
AsyncTask：異步任務，從字面上來說，就是在我們的UI主線程運行的時候，異步的完成一些操作。AsyncTask允許我們的執(zhí)行一個異步的任務在后臺。我們可以將耗時的操作放在異步任務當中來執(zhí)行，并隨時將任務執(zhí)行的結果返回給我們的UI線程來更新我們的UI控件。通過AsyncTask我們可以輕松的解決多線程之間的通信問題。
怎么來理解AsyncTask呢？通俗一點來說，AsyncTask就相當于Android給我們提供了一個多線程編程的一個框架，其介于Thread和Handler之間，我們如果要定義一個AsyncTask，就需要定義一個類來繼承AsyncTask這個抽象類，并實現其唯一的一doInBackgroud 抽象方法。
類簡介
AsyncTask = handler + 兩個線程池的維護一個任務隊列線程池，一個執(zhí)行線程池
其中：線程池用于線程調度、復用 & 執(zhí)行任務；
Handler用于異步通信
我們來看看AsyncTask這個抽象類的定義，當我們定義一個類來繼承AsyncTask這個類的時候，我們需要為其指定3個泛型參數：
AsyncTask <Params, Progress, Result>
- Params: 這個泛型指定的是我們傳遞給異步任務執(zhí)行時的參數的類型
- Progress: 這個泛型指定的是我們的異步任務在執(zhí)行的時候將執(zhí)行的進度返回給UI線程的參數的類型
- Result: 這個泛型指定的異步任務執(zhí)行完后返回給UI線程的結果的類型
簡單例子
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
//忽略
}
public void onClick(View v) {
try {
URL url = new URL("http://blog.csdn.net/");
new DownloadFilesTask().execute(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}執(zhí)行流程
一、在執(zhí)行完 AsyncTask.excute() 后
二、方法分析
常用的AsyncTask繼承的方法有
- onPreExecute()：異步任務開啟之前回調，在主線程中執(zhí)行
- doInBackground()：執(zhí)行異步任務，在線程池中執(zhí)行
- onProgressUpdate()：當doInBackground中調用publishProgress時回調，在主線程中執(zhí)行
- onPostExecute()：在異步任務執(zhí)行之后回調，在主線程中執(zhí)行
- onCancelled()：在異步任務被取消時回調
小demo
效果圖：
Activity
public class AsyThreadActivity extends Activity implements View.OnClickListener {
@BindView(R.id.btn_click)
Button btnClick;
@BindView(R.id.progress)
ProgressBar progress;
@BindView(R.id.btn_chancel)
Button btnChancel;
@BindView(R.id.text)
TextView text;
Mythread myasythread = new Mythread();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_asythread);
ButterKnife.bind(this);
initClcik();
}
private void initClcik() {
btnClick.setOnClickListener(this);
btnChancel.setOnClickListener(this);
myasythread.setOntextchance(new Mythread.Ontextchance() {
@Override
public void textchance(String s) {
text.setText(s);
}
@Override
public void progresschance(Integer number) {
progress.setProgress(number);
}
});
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_click:
myasythread.execute();
break;
case R.id.btn_chancel:
myasythread.cancel(true);
break;
default:
break;
}
}
}myAsyncTAsk
public class Mythread extends AsyncTask<String,Integer,String> {
private Ontextchance ontextchance;
public Mythread() {
super();
}
@Override
protected String doInBackground(String... params) {
int count = 0;
while(count<99){
count = count + 1;
publishProgress(count);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return null;
}
@Override
protected void onPreExecute() {
ontextchance.textchance("加載中");
super.onPreExecute();
}
@Override
protected void onPostExecute(String s) {
ontextchance.textchance("加載完畢");
super.onPostExecute(s);
}
@Override
protected void onProgressUpdate(Integer... values) {
ontextchance.progresschance(values[0]);
ontextchance.textchance("loading..." + values[0] + "%");
super.onProgressUpdate(values);
}
@Override
protected void onCancelled() {
ontextchance.textchance("已取消");
ontextchance.progresschance(0);
super.onCancelled();
}源碼分析
好吧 ，在想寫之前剛剛好瞄到一位小哥哥的文章寫得超級好，然后我就偷懶一把，如下。
源碼分析是基于API24的源碼，我將會按照下面AsyncTask運行的過程來分析
一、主分支
首先，execute()方法，開啟異步任務
接著，onPreExecute()方法，異步任務開啟前
接著，doInBackground()方法，異步任務正在執(zhí)行
最后，onPostExecute()方法，異步任務完成
二、次分支
onProgressUpdate()方法，異步任務更新UI
onCancelled()方法，異步任務取消
主分支部分
代碼開始的地方，是在創(chuàng)建AsyncTask類之后執(zhí)行的execute()方法
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}execute()方法會調用executeOnExecutor()方法
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定義了一個mStatus變量，表示異步任務的運行狀態(tài)，分別是PENDING、RUNNING、FINISHED，當只有PENDING狀態(tài)時，AsyncTask才會執(zhí)行，這樣也就保證了AsyncTask只會被執(zhí)行一次
繼續(xù)往下執(zhí)行，mStatus會被標記為RUNNING，接著執(zhí)行，onPreExecute()，將參數賦值給mWorker，然后還有execute(mFuture)
這里的mWorker和mFuture究竟是什么，我們往下追蹤，來到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);
}
}
};
}一、分析mWorker
mWorker是一個WorkerRunnable對象，跟蹤WorkerRunnable
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}實際上，WorkerRunnable是AsyncTask的一個抽象內部類，實現了Callable接口
二、分析mFuture
mFuture是一個FutureTask對象，跟蹤FutureTask
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}實際上，FutureTask是java.util.concurrent包下的一個類，參數是個callable，并且將它賦值給FutureTask類中的callable
三、回過頭來看
回到我們AsyncTask初始化mFuture，這里的參數是mWorker也就不奇怪了，因為mWorker就是一個callable，我們在上面賦值給FutureTask類中的callable就是這個mWorker
mFuture = new FutureTask<Result>(mWorker)
而關于mWorker和mFuture的初始化早在我們Activity中初始化好了，因為構造函數是跟AsyncTask類的創(chuàng)建而執(zhí)行的
new DownloadFilesTask()
知道了mWorker和mFuture是什么后，我們回到原來的executeOnExecutor()方法，在這里將mWorker的參數傳過去后，就開始用線程池execute這個mFuture
mWorker.mParams = params; exec.execute(mFuture);
一、分析exec
exec是通過executeOnExecutor()參數傳進來的
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params)也就是我們execute()方法傳過來的
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}這里可以看到exec就是這個sDefaultExecutor
二、分析sDefaultExecutor
我們跟蹤這個sDefaultExecutor，截取有關它的代碼
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可以發(fā)現，exec.execute(mFuture)就是在調用SerialExecutor類的execute(final Runnable r)方法，這里的參數r就是mFuture
繼續(xù)往下走，SerialExecutor的execute()方法會將r封裝成Runnable，并添加到mTasks任務隊列中
繼續(xù)往下走，如果這時候沒有正在活動的AsyncTask任務，那么就會調用SerialExecutor的scheduleNext()方法，來執(zhí)行下一個AsyncTask任務
if (mActive == null) {
scheduleNext();
}繼續(xù)往下走，通過mTasks.poll()取出，將封裝在mTask的Runnable交給mActive，最后真正執(zhí)行的這個mActive的是THREAD_POOL_EXECUTOR，即執(zhí)行的這個mActive，也就是包裝在Runnable里面的mFuture
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}mFuture被執(zhí)行了，也就會執(zhí)行它的run()方法
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}我們跟蹤到mFuture的run()方法中，切換到FutureTask類
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);
}
}這一段代碼其實就是將之前在mFutrue創(chuàng)建對象時候傳進來的mWorker交給c
Callable<V> c = callable;
然后再調用c的call()方法，也就是mWorker的call()方法
result = c.call();
代碼又重新的定位到了mWorker類的call()方法
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);
}
};可以發(fā)現，這里就調用了我們的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;
}觀察代碼，首先是getHandler()，它是一個單例，返回sHandler
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}也就是說postResult方法會通過sHandler發(fā)送一個MESSAGE_POST_RESULT的消息，這個時候我們追蹤到sHandler
private static InternalHandler sHandler;
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;
}
}
}可以發(fā)現，sHandler收到MESSAGE_POST_PROGRESS消息后會調用result.mTask.finish(result.mData[0])，那么我們還必須知道result是個什么東西
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
result是AsyncTask的內部類，實際上就是個實體類，用來存儲變量的
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}result.mTask也就是AsyncTask，最后調用result.mTask.finish(result.mData[0])，即AsyncTask的finish()方法，我們跟蹤到finish()方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}這里判斷AsyncTask是否已經取消，如果不取消就執(zhí)行我們的onPostExecute()，最后將狀態(tài)設置為FINISHED，整一個AsyncTask的方法都執(zhí)行完了，我們只需要繼承AsyncTask實現其中的方法就可以按分析的順序往下執(zhí)行了
次分支部分
在AsyncTask中的finish()方法，我們可以看到onCancelled()方法跟onPostExecute()一起的，只要isCancelled()的值為true，就執(zhí)行onCancelled()方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}我們代碼跟蹤isCancelled()方法
public final boolean isCancelled() {
return mCancelled.get();
}發(fā)現是在mCancelled中獲取的，那我們就必須知道這個mCancelled是什么，代碼跟蹤到mCancelled
private final AtomicBoolean mCancelled = new AtomicBoolean();
mCancelled實際上就是個Boolean對象，那我們搜索它是在哪個時候設置的
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}可以發(fā)現，只要我們在AsyncTask類中調用這個方法即可停止異步任務
而onProgressUpdate()方法，是在sHandler中執(zhí)行，sHandler收到MESSAGE_POST_PROGRESS消息后，執(zhí)行，我們搜索MESSAGE_POST_PROGRESS在什么時候發(fā)送的
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;
}
}
}可以發(fā)現，只要我們在AsyncTask類中調用publishProgress()方法即可執(zhí)行onProgressUpdate()方法
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}源碼原文：https://blog.csdn.net/qq_30379689/article/details/53203556
說實話上面源碼分析寫得真好，我在看了上面的源碼感覺少了一丟丟東西，自己在額外的補充一點東西
補充：THREAD_POOL_EXECUTOR
/**
* 源碼分析：THREAD_POOL_EXECUTOR.execute（）
* 說明：
* a. THREAD_POOL_EXECUTOR實際上是1個已配置好的可執(zhí)行并行任務的線程池
* b. 調用THREAD_POOL_EXECUTOR.execute（）實際上是調用線程池的execute()去執(zhí)行具體耗時任務
* c. 而該耗時任務則是步驟2中初始化WorkerRunnable實例對象時復寫的call（）
* 注：下面先看任務執(zhí)行線程池的線程配置過程，看完后請回到步驟2中的源碼分析call（）
*/
// 步驟1：參數設置
//獲得當前CPU的核心數
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//設置線程池的核心線程數2-4之間,但是取決于CPU核數
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
//設置線程池的最大線程數為 CPU核數*2+1
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//設置線程池空閑線程存活時間30s
private static final int KEEP_ALIVE_SECONDS = 30;
//初始化線程工廠
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());
}
};
//初始化存儲任務的隊列為LinkedBlockingQueue 最大容量為128
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
// 步驟2： 根據參數配置執(zhí)行任務線程池，即 THREAD_POOL_EXECUTOR
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
// 設置核心線程池的 超時時間也為30s
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}還有就是 我們可以通過源碼可以知道 使用AsyncTask執(zhí)行的后臺線程只有一個，這個結局看起來很悲傷。我們原以為執(zhí)行如下。
但是現實是這樣子的
被串行設置了 如下 synchronized
private static class SerialExecutor implements Executor {
// SerialExecutor = 靜態(tài)內部類
// 即 是所有實例化的AsyncTask對象公有的
// SerialExecutor 內部維持了1個雙向隊列；
// 容量根據元素數量調節(jié)
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
// execute（）被同步鎖synchronized修飾
// 即說明：通過鎖使得該隊列保證AsyncTask中的任務是串行執(zhí)行的
// 即 多個任務需1個個加到該隊列中；然后 執(zhí)行完隊列頭部的再執(zhí)行下一個，以此類推
public synchronized void execute(final Runnable r) {
// 將實例化后的FutureTask類 的實例對象傳入
// 即相當于：向隊列中加入一個新的任務
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();->>分析3
}
}
});
// 若當前無任務執(zhí)行，則去隊列中取出1個執(zhí)行
if (mActive == null) {
scheduleNext();
}
}
// 分析3
protected synchronized void scheduleNext() {
// 1. 取出隊列頭部任務
if ((mActive = mTasks.poll()) != null) {
// 2. 執(zhí)行取出的隊列頭部任務
// 即 調用執(zhí)行任務線程池類（THREAD_POOL_EXECUTOR）->>繼續(xù)往下看
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}好吧，我到現在還是沒有明白為什么他要如此限制，等哪位小哥哥，知道這個為什么的時候告訴我一聲，拜托拜托
如果我們還是想并行執(zhí)行，參考如下
方法一，繞過 excute 方法避免SerialExecutor 對象
方法二，繞過 excute 方法避免被轉換為 自定義線程池
方法三，在excute 方法將默認對象換為我們的 自定義線程池對象
//自定義線程池
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 60;
public static final Executor MY_THREAD_POOL_EXECUTOR;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
MY_THREAD_POOL_EXECUTOR = threadPoolExecutor;
} case R.id.btAsyncTaskSerial://串行執(zhí)行
new MyAsyncTask(mActivity, "Task#1 ").execute("123");
new MyAsyncTask(mActivity, "Task#2 ").execute("123");
new MyAsyncTask(mActivity, "Task#3 ").execute("123");
break;
case R.id.btAsyncTaskParallel://并行執(zhí)行 -- 這里使用 AsyncTask 自帶的線程池
new MyAsyncTask(mActivity, "Task#1 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#2 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#3 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
break;
case R.id.btAsyncTaskParallelByUs://并行執(zhí)行 -- 自定義線程池
new MyAsyncTask(mActivity, "Task#1 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#2 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
new MyAsyncTask(mActivity, "Task#3 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
break;
case R.id.btAsyncTaskParallelByUs2://并行執(zhí)行 -- 自定義線程池 另外一種方式
MyAsyncTask.setDefaultExecutor(MY_THREAD_POOL_EXECUTOR);//替換掉默認的 AsyncTask.SERIAL_EXECUTOR
new MyAsyncTask(mActivity, "Task#a ").execute("abc");
new MyAsyncTask(mActivity, "Task#b ").execute("abc");
new MyAsyncTask(mActivity, "Task#c ").execute("abc");
break;重要的事再次強調我到現在還是沒有明白為什么他要如此限制，等哪位小哥哥，知道這個為什么的時候告訴我一聲，拜托拜托
Thanks
到此這篇關于詳細講解AsyncTask使用說明(值得收藏)的文章就介紹到這了,更多相關AsyncTask使用內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家介紹了Android多套環(huán)境的維護思路詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-11-11
這篇文章主要為大家介紹了Flutter 枚舉值enum和int互相轉化總結分析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-02-02
這篇文章主要 給大家介紹了關于利用Kotlin的方式如何處理網絡異常的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2018-07-07
這篇文章主要為大家詳細介紹了懸浮對話框Android代碼實現，具有一定的參考價值，感興趣的小伙伴們可以參考一下2016-08-08
這篇文章主要為大家詳細介紹了Android實現APP秒表功能，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-09-09
開機密碼的樣式種類多種多樣，五花八門.本文接下來介紹滑動九宮格來達到開機目的，感興趣的朋友可以了解下2013-01-01
這篇文章主要給大家介紹了關于Android繪圖之Paint使用的相關資料，文中通過示例代碼介紹的非常詳細，并給大家介紹了DrawText 基線確定的方法，需要的朋友可以參考借鑒，下面隨著小編來一些學習學習吧。2017-11-11
這篇文章主要介紹了Android繪制文本與圖片及動效方法流程，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習吧2022-12-12
微信平臺開放后倒是挺火的，許多第三方應用都想試下接入微信這個平臺，畢竟可以利用微信建立起來的關系鏈來拓展自己的應用還是挺不錯的 最近由于實習需要也在研究這個東西，這里把我的整個研究情況給出來2013-01-01
Android基礎知識之tween動畫效果,Android一共提供了兩種動畫,這篇文章主要介紹了Android動畫效果之frame動畫，感興趣的小伙伴們可以參考一下2016-06-06