/**
* Run an ASync task on the corresponding executor
*
* @param task
* @return
*/
private AsyncTask<Void, Void, Void> runAsyncTask(AsyncTask<Void, Void, Void> task) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
return task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
} else {
return task.execute();
}
}
public static void startWithParams(AsyncTask task, Object[] params) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
} else {
task.execute(params);
}
}
@Override
public synchronized void onAutoFocus(boolean success, Camera theCamera) {
if (active) {
outstandingTask = new AutoFocusTask();
outstandingTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
}
public static void start(AsyncTask task) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, new Void[] {});
} else {
task.execute(new Void[] {});
}
}
@SuppressLint("NewApi")
public DiskLruCache(Context context, String cacheName, long cacheSize) {
mContext = context;
mCacheName = cacheName;
mCacheSize = cacheSize;
int version;
PackageManager pm = context.getPackageManager();
try {
PackageInfo pi = pm.getPackageInfo(context.getPackageName(), 0);
version = pi.versionCode;
} catch (NameNotFoundException e) {
version = 1;
}
AsyncTask<Integer, Object, Object> task =
new AsyncTask<Integer, Object, Object>() {
@Override
protected Object doInBackground(Integer... params) {
initDiskCache(params[0]);
return null;
}
};
if (Build.VERSION.SDK_INT >= 11) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, version);
} else {
task.execute(version);
}
}
private void fetchPhotoAsync(final RecipientEntry entry, final Uri photoThumbnailUri) {
final AsyncTask<Void, Void, Void> photoLoadTask =
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
final Cursor photoCursor =
mContentResolver.query(photoThumbnailUri, PhotoQuery.PROJECTION, null, null, null);
if (photoCursor != null) {
try {
if (photoCursor.moveToFirst()) {
final byte[] photoBytes = photoCursor.getBlob(PhotoQuery.PHOTO);
entry.setPhotoBytes(photoBytes);
mHandler.post(
new Runnable() {
@Override
public void run() {
mPhotoCacheMap.put(photoThumbnailUri, photoBytes);
notifyDataSetChanged();
}
});
}
} finally {
photoCursor.close();
}
}
return null;
}
};
photoLoadTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
}
/** 首先终止之前的监控任务，然后新起一个监控任务 */
@SuppressWarnings("unchecked")
@SuppressLint("NewApi")
public synchronized void onActivity() {
cancel();
inactivityTask = new InactivityAsyncTask();
inactivityTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
public void onClickAsyncThreadSerial(final View view) {
AsyncTask a = new CustomAsyncTask();
Integer i = (Integer) view.getTag();
if (i == null) i = 1;
view.setTag(i + 1);
a.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, "Some", i, "SERIAL_EXECUTOR");
}
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
private <A, B, C> void executeTask(AsyncTask<A, B, C> task, A... params) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
} else {
task.execute(params);
}
}
@TargetApi(11)
public static <T> void executeAsyncTask(AsyncTask<T, ?, ?> task, T... params) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
} else {
task.execute(params);
}
}
public static void startMyTask(AsyncTask asyncTask) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null);
} else {
asyncTask.execute();
}
}
public Server(int _port, PollListener _pollListener) {
port = _port;
client = new Socket[2];
objectInputStreams = new ObjectInputStream[2];
clientPoll = new ArrayList<AsyncTask<Integer, Object, Void>>();
pollListener = _pollListener;
serverStart =
new AsyncTask<Void, Socket, Void>() {
@Override
protected Void doInBackground(Void... params) {
Thread.currentThread().setName("ServerThread");
try {
serverSocket = new ServerSocket(port);
serverSocket.setSoTimeout(1000);
} catch (IOException e) {
}
while ((client[0] == null || client[1] == null) && !isCancelled()) {
try {
publishProgress(serverSocket.accept());
} catch (IOException e) {
}
}
return null;
}
@Override
protected void onProgressUpdate(Socket... values) {
new AsyncTask<Socket, Void, Void>() {
@Override
protected Void doInBackground(Socket... params) {
Thread.currentThread().setName("TryClientThread");
tryClient(params[0]);
return null;
}
}.executeOnExecutor(Executors.newSingleThreadExecutor(), values[0]);
};
@Override
protected void onPostExecute(Void result) {
Log.d("netconnect", "serverFinished");
serverWorking = true;
AsyncPoll();
};
@Override
protected void onCancelled() {
asyncClean();
}
};
serverStart.executeOnExecutor(Executors.newSingleThreadExecutor(), new Void[] {null});
}
private void launchSearch() {
String query = queryTextView.getText().toString();
if (query != null && !query.isEmpty()) {
AsyncTask<?, ?, ?> oldTask = networkTask;
if (oldTask != null) {
oldTask.cancel(true);
}
networkTask = new NetworkTask();
networkTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, query, isbn);
headerView.setText(R.string.msg_sbc_searching_book);
resultListView.setAdapter(null);
queryTextView.setEnabled(false);
queryButton.setEnabled(false);
}
}
/**
* {@link AsyncTask#execute(Object...)}は，API level 11以降ではシリアルに実行されます．<br>
* （複数個登録した場合，1つ終わらないと次が開始されない）<br>
* このメソッドを介して呼んだ場合，パラレルに実行されます．<br>
*
* @param task
* @param params
* @see <a href="http://daichan4649.hatenablog.jp/entry/20120125/1327467103">参考ページ</a>
*/
@SuppressLint("NewApi")
public static <T> void executeTask(AsyncTask<T, ?, ?> task, T... params) {
try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
} else {
task.execute(params);
}
} catch (RejectedExecutionException e) {
LogUtils.d("Pool is full. Retrying...");
executeTask(task, params);
} catch (IllegalStateException e) {
LogUtils.w("This Task may be already runnning. " + e.toString());
}
}
@TargetApi(11)
public static <T> AsyncTask<T, ?, ?> executeTaskOnExecutor(AsyncTask<T, ?, ?> task, T... arg) {
for (int i = 0; i < 2; i++) {
try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, arg);
} else {
task.execute(arg);
}
break;
} catch (RejectedExecutionException ignore) {
Logger.w("unable to start thread", ignore);
sleep(1000);
}
}
return task;
}
private void connect(final LoLin1Account acc) {
mSmackAndroid = LoLChat.init(getApplicationContext());
mLoginTask =
new AsyncTask<LoLin1Account, Void, Void>() {
@Override
protected Void doInBackground(LoLin1Account... params) {
Boolean loginSuccess = login(params[0]);
if (loginSuccess) {
launchBroadcastLoginSuccessful();
setUpChatOverviewListener();
} else {
launchBroadcastLoginFailed();
}
return null;
}
};
mLoginTask.executeOnExecutor(Executors.newSingleThreadExecutor(), acc);
}
private void registerInBackground() {
AsyncTask<String, String, Boolean> task =
new AsyncTask<String, String, Boolean>() {
@Override
protected Boolean doInBackground(String... objects) {
if (gcm == null) {
gcm = GoogleCloudMessaging.getInstance(applicationContext);
}
int count = 0;
while (count < 1000) {
try {
count++;
regid = gcm.register(BuildVars.GCM_SENDER_ID);
sendRegistrationIdToBackend(true);
storeRegistrationId(applicationContext, regid);
return true;
} catch (Exception e) {
FileLog.e("tmessages", e);
}
try {
if (count % 20 == 0) {
Thread.sleep(60000 * 30);
} else {
Thread.sleep(5000);
}
} catch (InterruptedException e) {
FileLog.e("tmessages", e);
}
}
return false;
}
};
if (android.os.Build.VERSION.SDK_INT >= 11) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null, null, null);
} else {
task.execute(null, null, null);
}
}
/** 加载更多，开启异步线程，并且显示加载中的界面，当数据加载完成自动还原成加载完成的布局，并且刷新列表数据 */
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public void loadMore() {
if (isLoading()) {
return;
}
if (dataAdapter.isEmpty()) {
refresh();
return;
}
if (dataAdapter == null || dataSource == null) {
if (refreshView != null) {
refreshView.showRefreshComplete();
}
return;
}
if (asyncTask != null && asyncTask.getStatus() != AsyncTask.Status.FINISHED) {
asyncTask.cancel(true);
}
asyncTask =
new AsyncTask<Void, Void, DATA>() {
protected void onPreExecute() {
onStateChangeListener.onStartLoadMore(dataAdapter);
if (mLoadMoreView != null) {
mLoadMoreView.showLoading();
}
}
@Override
protected DATA doInBackground(Void... params) {
try {
return dataSource.loadMore();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
protected void onPostExecute(DATA result) {
if (result == null) {
mLoadView.tipFail();
if (mLoadMoreView != null) {
mLoadMoreView.showFail();
}
} else {
dataAdapter.notifyDataChanged(result, false);
if (dataAdapter.isEmpty()) {
mLoadView.showEmpty();
} else {
mLoadView.restore();
}
hasMoreData = dataSource.hasMore();
if (mLoadMoreView != null) {
if (hasMoreData) {
mLoadMoreView.showNormal();
} else {
mLoadMoreView.showNomore();
}
}
}
onStateChangeListener.onEndLoadMore(dataAdapter, result);
};
};
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
} else {
asyncTask.execute();
}
}
static <Params, Progress, Result> void m692a(
AsyncTask<Params, Progress, Result> asyncTask, Params... paramsArr) {
asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, paramsArr);
}
@Override
public <T> AsyncTask<T, ?, ?> submit(Object identifer, AsyncTask<T, ?, ?> task, T... params) {
checkCalledFromUiThread();
return task.executeOnExecutor(mExecutor, params);
}
synchronized void onActivity() {
cancel();
inactivityTask = new InactivityAsyncTask();
inactivityTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
@TargetApi(Constants.HONEYCOMB)
private static void executeTaskHoneycomb(AsyncTask<Void, Void, Void> task) {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
private void reloadFrames(int frameNum) {
if (mediaMetadataRetriever == null) {
return;
}
if (frameNum == 0) {
frameHeight = AndroidUtilities.dp(40);
framesToLoad = (getMeasuredWidth() - AndroidUtilities.dp(16)) / frameHeight;
frameWidth =
(int)
Math.ceil(
(float) (getMeasuredWidth() - AndroidUtilities.dp(16)) / (float) framesToLoad);
frameTimeOffset = videoLength / framesToLoad;
}
currentTask =
new AsyncTask<Integer, Integer, Bitmap>() {
private int frameNum = 0;
@Override
protected Bitmap doInBackground(Integer... objects) {
frameNum = objects[0];
Bitmap bitmap = null;
if (isCancelled()) {
return null;
}
try {
bitmap = mediaMetadataRetriever.getFrameAtTime(frameTimeOffset * frameNum * 1000);
if (isCancelled()) {
return null;
}
if (bitmap != null) {
Bitmap result = Bitmap.createBitmap(frameWidth, frameHeight, bitmap.getConfig());
Canvas canvas = new Canvas(result);
float scaleX = (float) frameWidth / (float) bitmap.getWidth();
float scaleY = (float) frameHeight / (float) bitmap.getHeight();
float scale = scaleX > scaleY ? scaleX : scaleY;
int w = (int) (bitmap.getWidth() * scale);
int h = (int) (bitmap.getHeight() * scale);
Rect srcRect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
Rect destRect = new Rect((frameWidth - w) / 2, (frameHeight - h) / 2, w, h);
Paint paint = new Paint();
canvas.drawBitmap(bitmap, srcRect, destRect, null);
bitmap.recycle();
bitmap = result;
}
} catch (Exception e) {
FileLog.e("tmessages", e);
}
return bitmap;
}
@Override
protected void onPostExecute(Bitmap bitmap) {
if (!isCancelled()) {
frames.add(bitmap);
invalidate();
if (frameNum < framesToLoad) {
reloadFrames(frameNum + 1);
}
}
}
};
if (android.os.Build.VERSION.SDK_INT >= 11) {
currentTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, frameNum, null, null);
} else {
currentTask.execute(frameNum, null, null);
}
}
static transient void executeParallel(AsyncTask asynctask, Object aobj[]) {
asynctask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, aobj);
}
@TargetApi(11)
/**
* Execute the given task
*
* <p>The busy state is notified to the client
*
* <p>Tasks should throw an exception to indicate (and return) error
*
* @param task the Runnable task to be performed
*/
public void performTask(Runnable task) throws ModelException {
final Runnable rTask = task;
if (mCommander == null) {
throw (new ModelException("There is no AsciiCommander set for this model!"));
} else {
if (mTaskRunner != null) {
throw (new ModelException("Task is already running!"));
} else {
mTaskRunner =
new AsyncTask<Void, Void, Void>() {
@Override
protected void onPreExecute() {
mLastTaskExecutionDuration = -1.0;
mTaskStartTime = new Date();
}
protected Void doInBackground(Void... voids) {
try {
setBusy(true);
mException = null;
rTask.run();
} catch (Exception e) {
mException = e;
}
return null;
}
@Override
protected void onPostExecute(Void result) {
super.onPostExecute(result);
mTaskRunner = null;
setBusy(false);
// Update the time taken
Date finishTime = new Date();
mLastTaskExecutionDuration =
(finishTime.getTime() - mTaskStartTime.getTime()) / 1000.0;
if (D)
Log.i(
getClass().getName(),
String.format(
"Time taken (ms): %d %.2f",
finishTime.getTime() - mTaskStartTime.getTime(),
mLastTaskExecutionDuration));
}
};
try {
if (android.os.Build.VERSION.SDK_INT >= 11) {
// Ensure the tasks are executed serially whatever newer API versions may choose by
// default
mTaskRunner.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, (Void[]) null);
} else {
// Tasks will be executed concurrently on API < 11
mTaskRunner.execute((Void[]) null);
}
} catch (Exception e) {
mException = e;
}
}
}
}
