반응형
비동기 작업 Android 예제
에 대해 읽고 있었습니다.AsyncTask그리고 아래의 간단한 프로그램을 시도했습니다.하지만 효과가 없는 것 같습니다.어떻게 하면 작동할 수 있을까요?
public class AsyncTaskActivity extends Activity {
Button btn;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn = (Button) findViewById(R.id.button1);
btn.setOnClickListener((OnClickListener) this);
}
public void onClick(View view){
new LongOperation().execute("");
}
private class LongOperation extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... params) {
for(int i=0;i<5;i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");
return null;
}
@Override
protected void onPostExecute(String result) {
}
@Override
protected void onPreExecute() {
}
@Override
protected void onProgressUpdate(Void... values) {
}
}
}
나는 단지 백그라운드 작업에서 5초 후에 라벨을 바꾸려고 합니다.
이것은 나의 main.xml입니다.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<ProgressBar
android:id="@+id/progressBar"
style="?android:attr/progressBarStyleHorizontal"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:indeterminate="false"
android:max="10"
android:padding="10dip">
</ProgressBar>
<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Start Progress" >
</Button>
<TextView android:id="@+id/output"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Replace"/>
</LinearLayout>
제 전체 답변은 여기에 있지만, 이 페이지의 다른 답변을 보완하기 위한 설명 이미지가 있습니다.저는 처음에 모든 변수가 어디로 가는지 이해하는 것이 가장 혼란스러웠습니다.
다른 스레드를 통해 GUI에 액세스하려고 합니다.대체로 이것은 좋은 관행이 아닙니다.
는 비기작다모작실업행다의 모든 합니다.doInBackground()보기가 있는 GUI에 액세스할 수 없는 다른 스레드 내부.
preExecute()그리고.postExecute()스레드에서 수 하며, 긴를 이새로스에전후발생기 GUI하대며제, 긴작업의있수다습니도전에할결달를과에 전달할 수도 있습니다.postExecute()처리 결과를 표시합니다.
나중에 TextView를 업데이트할 때 다음 행을 참조하십시오.
TextView txt = findViewById(R.id.output);
txt.setText("Executed");
을 집넣어에 .onPostExecute().
그러면 TextView 텍스트가 다음 이후에 업데이트되는 것을 볼 수 있습니다.doInBackground완료합니다.
온클릭 청취자가 선택한 보기를 확인하지 않습니다.이를 위한 가장 쉬운 방법은 스위치 문을 사용하는 것입니다.저는 혼란을 줄이기 위해 아래의 모든 제안을 포함한 전체 수업을 편집했습니다.
import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.provider.Settings.System;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.view.View.OnClickListener;
public class AsyncTaskActivity extends Activity implements OnClickListener {
Button btn;
AsyncTask<?, ?, ?> runningTask;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn = findViewById(R.id.button1);
// Because we implement OnClickListener, we only
// have to pass "this" (much easier)
btn.setOnClickListener(this);
}
@Override
public void onClick(View view) {
// Detect the view that was "clicked"
switch (view.getId()) {
case R.id.button1:
if (runningTask != null)
runningTask.cancel(true);
runningTask = new LongOperation();
runningTask.execute();
break;
}
}
@Override
protected void onDestroy() {
super.onDestroy();
// Cancel running task(s) to avoid memory leaks
if (runningTask != null)
runningTask.cancel(true);
}
private final class LongOperation extends AsyncTask<Void, Void, String> {
@Override
protected String doInBackground(Void... params) {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// We were cancelled; stop sleeping!
}
}
return "Executed";
}
@Override
protected void onPostExecute(String result) {
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed"); // txt.setText(result);
// You might want to change "executed" for the returned string
// passed into onPostExecute(), but that is up to you
}
}
}
제대로 실행되고 있지만 백그라운드 스레드에서 UI 요소를 변경하려고 하면 변경할 수 없습니다.
다음과 같이 통화 및 비동기 작업을 수정합니다.
호출 클래스
참고: 개인적으로 사용할 것을 제안합니다.onPostExecute()비동기 작업 자체를 확장하는 클래스가 아닌 비동기 작업 스레드를 실행하는 모든 위치.특히 결과를 처리하는 여러 장소에서 비동기 작업이 필요한 경우 코드를 읽기 쉽게 해준다고 생각합니다.
new LongThread() {
@Override public void onPostExecute(String result) {
TextView txt = (TextView) findViewById(R.id.output);
txt.setText(result);
}
}.execute("");
LongThread 클래스(AsyncTask 확장):
@Override
protected String doInBackground(String... params) {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return "Executed";
}
안드로이드의 비동기 작업을 사용하기 위한 간단한 예제를 만들었습니다.으로 합니다.onPreExecute(), doInBackground(), publishProgress()그리고 마지막으로onProgressUpdate().
여기서 doInBackground()는 백그라운드 스레드로 작동하고 다른 것은 UI 스레드에서 작동합니다.DoInBackground()의 UI 요소에 액세스할 수 없습니다.그 순서는 제가 언급한 것과 같습니다.
, 에서 doInBackground,넌 할 수 있다.publishProgressdoInBackground전화가 올 것입니다.onProgressUpdateUI 위젯을 업데이트합니다.
class TestAsync extends AsyncTask<Void, Integer, String> {
String TAG = getClass().getSimpleName();
protected void onPreExecute() {
super.onPreExecute();
Log.d(TAG + " PreExceute","On pre Exceute......");
}
protected String doInBackground(Void...arg0) {
Log.d(TAG + " DoINBackGround", "On doInBackground...");
for (int i=0; i<10; i++){
Integer in = new Integer(i);
publishProgress(i);
}
return "You are at PostExecute";
}
protected void onProgressUpdate(Integer...a) {
super.onProgressUpdate(a);
Log.d(TAG + " onProgressUpdate", "You are in progress update ... " + a[0]);
}
protected void onPostExecute(String result) {
super.onPostExecute(result);
Log.d(TAG + " onPostExecute", "" + result);
}
}
활동에서 이를 다음과 같이 부릅니다.
new TestAsync().execute();
다음 두 줄을 이동합니다.
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");
의 "AsyncTask"에서 됩니다.doInBackground방법과 그것들을 그 안에 넣습니다.onPostExecute방법.당신의.AsyncTask다음과 같이 보여야 합니다.
private class LongOperation extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... params) {
try {
Thread.sleep(5000); // no need for a loop
} catch (InterruptedException e) {
Log.e("LongOperation", "Interrupted", e);
return "Interrupted";
}
return "Executed";
}
@Override
protected void onPostExecute(String result) {
TextView txt = (TextView) findViewById(R.id.output);
txt.setText(result);
}
}
비동기 작업에서 사용되는 매개 변수를 어떻게 기억합니까?
하지 마
비동기 작업을 처음 사용하는 경우 비동기 작업을 작성하는 동안 혼동되는 경우가 매우 많습니다.주요 원인은 비동기 작업에 사용되는 매개 변수입니다.AsyncTask<A, B, C>방법의 A, B, C(인수) 서명을 기반으로 하여 상황을 더욱 혼란스럽게 만듭니다.
단순하게 하세요!
핵심은 외우지 않는 것입니다.작업이 실제로 무엇을 해야 하는지 시각화할 수 있다면 첫 번째 시도에서 정확한 서명을 사용하여 비동기 작업을 작성하는 것은 식은 죽 먹기입니다.당신이 무엇을 하는지 알아보세요.Input,Progress,그리고.Output."라고, 그고당가도좋습니다신은네리좋다▁are니습가,도당네신,.
비동기 작업이란 무엇입니까?
비동기 작업은 백그라운드 스레드에서 실행되는 백그라운드 작업입니다.시간이 걸립니다.InputProgress라고 대답합니다.Output.
즉,
AsyncTask<Input, Progress, Output>.
예:
방법과 어떤 관계가 있습니까?
사이
AsyncTask그리고.doInBackground()
doInBackground()그리고.onPostExecute(),도 ProgressUpdate() '와 관련이.
그걸 어떻게 코드에 적나요?
DownloadTask extends AsyncTask<String, Integer, String>{
// Always same signature
@Override
public void onPreExecute()
{}
@Override
public String doInbackGround(String... parameters)
{
// Download code
int downloadPerc = // Calculate that
publish(downloadPerc);
return "Download Success";
}
@Override
public void onPostExecute(String result)
{
super.onPostExecute(result);
}
@Override
public void onProgressUpdate(Integer... parameters)
{
// Show in spinner, and access UI elements
}
}
이 작업을 어떻게 실행하시겠습니까?
new DownLoadTask().execute("Paradise.mp3");
배경 / 이론
비동기 작업을 사용하면 결과를 UI 스레드에 게시하는 동안 백그라운드 스레드에서 작업을 실행할 수 있습니다.
사용자는 항상 앱과 상호 작용할 수 있어야 하므로 웹에서 콘텐츠를 다운로드하는 등의 작업으로 메인(UI) 스레드를 차단하지 않는 것이 중요합니다.
이것이 우리가 를 사용하는 이유입니다.
다른 스레드에서 실행 가능한 개체와 메시지를 보내고 처리할 수 있는 UI 스레드 메시지 대기열과 핸들러를 감싸 간단한 인터페이스를 제공합니다.
실행
AsyncTask는 제네릭 클래스입니다.(생성자에서 매개 변수화된 유형을 사용합니다.)
다음 세 가지 일반 유형을 사용합니다.
Params 실행 시 태스크로 전송되는 매개 변수의 유형입니다.
Progress 백그라운드 계산 중에 게시된 진행 단위의 유형입니다.
Result 백그라운드 계산 결과의 유형입니다.
모든 유형이 비동기 작업에서 항상 사용되는 것은 아닙니다.유형을 사용하지 않음으로 표시하려면 Void 유형을 사용합니다.
private class MyTask extends AsyncTask<Void, Void, Void> { ... }
이 세 가지 파라미터는 에서 재정의할 수 있는 세 가지 주요 기능에 해당합니다.
doInBackground(Params...)onProgressUpdate(Progress...)onPostExecute(Result)
비동기 작업 실행 방법
- 백그라운드 작업으로 보낼 매개 변수가 있는 호출입니다.
해프닝
온 메인/UI 스레드를 호출합니다.
- 이 스레드에서 무언가를 초기화합니다(예: 사용자 인터페이스에 진행률 표시줄 표시).
백그라운드 스레드에서 를 호출합니다.
- (
Params을 통해 전달되었습니다.execute.) - 장기 실행 작업이 발생해야 하는 위치입니다.
재정해합니다를 해야 합니다.
doInBackground()비동기 작업을 사용합니다.백그라운드 계산이 실행 중인 동안 진행 상황 표시(예: UI 애니메이션 또는 로그 텍스트 인쇄)로 사용자 인터페이스를 업데이트하기 위해 호출합니다.
- 호출할 원인입니다.
- (
백그라운드 스레드에서 결과가 반환됩니다.
doInBackground().- (다음 단계가 트리거됩니다.)
온 메인/반환된 결과와 함께 UI 스레드가 호출됩니다.
예
두 예 모두 "차단 작업"은 웹에서 다운로드한 것입니다.
- 예 A는 이미지를 다운로드하여 이미지 보기에 표시하는 동안
- 예제 B는 일부 파일을 다운로드합니다.
예 A
그doInBackground()하여 BitMapmethod 합니다. 그onPostExecute()메소드는 비트맵을 가져와 이미지 보기에 배치합니다.
class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
ImageView bitImage;
public DownloadImageTask(ImageView bitImage) {
this.bitImage = bitImage;
}
protected Bitmap doInBackground(String... urls) {
String urldisplay = urls[0];
Bitmap mBmp = null;
try {
InputStream in = new java.net.URL(urldisplay).openStream();
mBmp = BitmapFactory.decodeStream(in);
} catch (Exception e) {
Log.e("Error", e.getMessage());
e.printStackTrace();
}
return mBmp;
}
protected void onPostExecute(Bitmap result) {
bitImage.setImageBitmap(result);
}
}
예 B
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
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");
}
}
예제 B 실행
new DownloadFilesTask().execute(url1, url2, url3);
비동기 작업이 실행될 때 작업은 다음과 같은 4단계를 거칩니다.
- 사전 실행 시()
- 백그라운드에서 수행(파라미터...)
- 진행률 업데이트 시(진행률...)
- 실행 후(결과)
다음은 데모 예제입니다.
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
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");
}
}
생성한 후에는 작업이 매우 간단하게 실행됩니다.
new DownloadFilesTask().execute(url1, url2, url3);
비동기식으로 무언가를 수행하는 것에 대한 간단한 예:
class MyAsyncTask extends android.os.AsyncTask {
@Override
protected Object doInBackground(Object[] objects) {
// Do something asynchronously
return null;
}
}
실행 방법:
(new MyAsyncTask()).execute();
작업자 스레드에서는 Android에서 UI 요소를 직접 조작할 수 없습니다.
비동기 작업을 사용하는 경우 콜백 방법을 이해하십시오.
예:
public class MyAyncTask extends AsyncTask<Void, Void, Void>{
@Override
protected void onPreExecute() {
// Here you can show progress bar or something on the similar lines.
// Since you are in a UI thread here.
super.onPreExecute();
}
@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
// After completing execution of given task, control will return here.
// Hence if you want to populate UI elements with fetched data, do it here.
}
@Override
protected void onProgressUpdate(Void... values) {
super.onProgressUpdate(values);
// You can track you progress update here
}
@Override
protected Void doInBackground(Void... params) {
// Here you are in the worker thread and you are not allowed to access UI thread from here.
// Here you can perform network operations or any heavy operations you want.
return null;
}
}
참고: 작업자 스레드에서 UI 스레드에 액세스하려면 보기에서 runOnUiThread() 메서드를 사용하거나 post 메서드를 사용합니다.
예를 들어:
runOnUiThread(new Runnable() {
textView.setText("something.");
});
or
yourview.post(new Runnable() {
yourview.setText("something");
});
이것은 당신이 그것들을 더 잘 알 수 있도록 도와줄 것입니다.따라서 당신의 경우, 당신은 당신의 텍스트 뷰를 온 포스트에서 설정해야 합니다.Execute() 메서드입니다.
이 라이브러리를 배경 작업에 사용하여 생활을 더 쉽게 하는 것을 추천합니다.
https://github.com/Arasthel/AsyncJobLibrary
이렇게 간단한...
AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {
@Override
public void doOnBackground() {
startRecording();
}
});
POST 요청이 있는 샘플 비동기 작업:
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("key1", "value1"));
params.add(new BasicNameValuePair("key1", "value2"));
new WEBSERVICEREQUESTOR(URL, params).execute();
class WEBSERVICEREQUESTOR extends AsyncTask<String, Integer, String>
{
String URL;
List<NameValuePair> parameters;
private ProgressDialog pDialog;
public WEBSERVICEREQUESTOR(String url, List<NameValuePair> params)
{
this.URL = url;
this.parameters = params;
}
@Override
protected void onPreExecute()
{
pDialog = new ProgressDialog(LoginActivity.this);
pDialog.setMessage("Processing Request...");
pDialog.setIndeterminate(false);
pDialog.setCancelable(false);
pDialog.show();
super.onPreExecute();
}
@Override
protected String doInBackground(String... params)
{
try
{
DefaultHttpClient httpClient = new DefaultHttpClient();
HttpEntity httpEntity = null;
HttpResponse httpResponse = null;
HttpPost httpPost = new HttpPost(URL);
if (parameters != null)
{
httpPost.setEntity(new UrlEncodedFormEntity(parameters));
}
httpResponse = httpClient.execute(httpPost);
httpEntity = httpResponse.getEntity();
return EntityUtils.toString(httpEntity);
} catch (Exception e)
{
}
return "";
}
@Override
protected void onPostExecute(String result)
{
pDialog.dismiss();
try
{
}
catch (Exception e)
{
}
super.onPostExecute(result);
}
}
업데이트: 2020년 3월
안드로이드 개발자 공식 문서에 따르면 비동기 작업은 이제 더 이상 사용되지 않습니다.
대신 코틀린 코로린을 사용하는 것이 좋습니다.간단히 말해 비동기 작업을 순차적인 스타일로 작성할 수 있습니다.
단순:
LongOperation MyTask = new LongOperation();
MyTask.execute();
클릭 수신기의 버튼을 선언해야 합니다.클릭하면 AsyncTask 클래스 DownloadJson이 호출됩니다.
프로세스는 다음과 같습니다.
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn = (Button) findViewById(R.id.button1);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new DownloadJson().execute();
}
});
}
// DownloadJSON AsyncTask
private class DownloadJson extends AsyncTask<Void, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected Void doInBackground(Void... params) {
newlist = new ArrayList<HashMap<String, String>>();
json = jsonParser.makeHttpRequest(json, "POST");
try {
newarray = new JSONArray(json);
for (int i = 0; i < countdisplay; i++) {
HashMap<String, String> eachnew = new HashMap<String, String>();
newobject = newarray.getJSONObject(i);
eachnew.put("id", newobject.getString("ID"));
eachnew.put("name", newobject.getString("Name"));
newlist.add(eachnew);
}
}
} catch (JSONException e) {
Log.e("Error", e.getMessage());
e.printStackTrace();
}
return null;
}
@Override
protected void onPostExecute(Void args) {
newlisttemp.addAll(newlist);
NewAdapterpager newadapterpager = new NewAdapterpager(ProcesssActivitypager.this, newlisttemp);
newpager.setAdapter(newadapterpager);
}
}
private class AsyncTaskDemo extends AsyncTask<Void, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
// Showing progress dialog
progressDialog = new ProgressDialog(this);
progressDialog.setMessage("Loading...");
progressDialog.setCancelable(false);
progressDialog.show();
}
@Override
protected Void doInBackground(Void... arg0) {
// Do code here
return null;
}
@Override
protected void onPostExecute(Void result) {
super.onPostExecute(result);
// Dismiss the progress dialog
if (progressDialog.isShowing()) {
progressDialog.dismiss();
}
}
@Override
protected void onCancelled() {
super.onCancelled();
progressDialog.dismiss();
Toast toast = Toast.makeText(
getActivity(),
"An error is occurred due to some problem",
Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP, 25, 400);
toast.show();
}
}
AsyncTask로 작업하는 동안 클래스 후계자를 만들고 그 안에 우리에게 필요한 메서드의 구현을 등록해야 합니다.이 과정에서는 세 가지 방법을 살펴보겠습니다.
DoInBackground - 새로운 스레드에서 실행되며, 여기서 우리는 모든 어려운 작업을 해결합니다.주 스레드가 아닌 스레드는 UI에 액세스할 수 없기 때문입니다.
onPreExecute - doInBackground 이전에 실행되며 UI에 액세스할 수 있습니다.
onPostExecute - doInBackground 이후에 실행됨(다음 레슨에서 비동기 작업이 취소된 경우 작동하지 않음) 및 UI에 액세스할 수 있습니다.
MyAsyncTask 클래스입니다.
class MyAsyncTask extends AsyncTask<Void, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
tvInfo.setText("Start");
}
@Override
protected Void doInBackground(Void... params) {
// Your background method
return null;
}
@Override
protected void onPostExecute(Void result) {
super.onPostExecute(result);
tvInfo.setText("Finish");
}
}
활동 또는 단편을 호출하는 방법은 다음과 같습니다.
MyAsyncTask myAsyncTask = new MyAsyncTask();
myAsyncTask.execute();
비동기 작업:
public class MainActivity extends AppCompatActivity {
private String ApiUrl="your_api";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
MyTask myTask=new MyTask();
try {
String result=myTask.execute(ApiUrl).get();
Toast.makeText(getApplicationContext(),result,Toast.LENGTH_SHORT).show();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public class MyTask extends AsyncTask<String,Void,String>{
@Override
protected String doInBackground(String... strings) {
String result="";
HttpURLConnection httpURLConnection=null;
URL url;
try {
url=new URL(strings[0]);
httpURLConnection=(HttpURLConnection) url.openConnection();
InputStream inputStream=httpURLConnection.getInputStream();
InputStreamReader reader=new InputStreamReader(inputStream);
result=getData(reader);
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
public String getData(InputStreamReader reader) throws IOException{
String result="";
int data=reader.read();
while (data!=-1){
char now=(char) data;
result+=data;
data=reader.read();
}
return result;
}
}
}
진행 중인 비동기 작업 예제
import android.animation.ObjectAnimator;
import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.LinearInterpolator;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
public class AsyncTaskActivity extends AppCompatActivity implements View.OnClickListener {
Button btn;
ProgressBar progressBar;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn = (Button) findViewById(R.id.button1);
btn.setOnClickListener(this);
progressBar = (ProgressBar)findViewById(R.id.pbar);
}
public void onClick(View view) {
switch (view.getId()) {
case R.id.button1:
new LongOperation().execute("");
break;
}
}
private class LongOperation extends AsyncTask<String, Integer, String> {
@Override
protected String doInBackground(String... params) {
Log.d("AsyncTask", "doInBackground");
for (int i = 0; i < 5; i++) {
try {
Log.d("AsyncTask", "task "+(i + 1));
publishProgress(i + 1);
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.interrupted();
}
}
return "Completed";
}
@Override
protected void onPostExecute(String result) {
Log.d("AsyncTask", "onPostExecute");
TextView txt = (TextView) findViewById(R.id.output);
txt.setText(result);
progressBar.setProgress(0);
}
@Override
protected void onPreExecute() {
Log.d("AsyncTask", "onPreExecute");
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("onPreExecute");
progressBar.setMax(500);
progressBar.setProgress(0);
}
@Override
protected void onProgressUpdate(Integer... values) {
Log.d("AsyncTask", "onProgressUpdate "+values[0]);
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("onProgressUpdate "+values[0]);
ObjectAnimator animation = ObjectAnimator.ofInt(progressBar, "progress", 100 * values[0]);
animation.setDuration(1000);
animation.setInterpolator(new LinearInterpolator());
animation.start();
}
}
}
AsyncTask 클래스를 열면 아래 코드를 볼 수 있습니다.
public abstract class AsyncTask<Params, Progress, Result> {
@WorkerThread
protected abstract Result doInBackground(Params... params);
@MainThread
protected void onPreExecute() {
}
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onPostExecute(Result result) {
}
}
비동기 작업 기능
- AsyncTask가 추상 클래스입니다.
- AsyncTask에는 3개의 일반 매개 변수가 있습니다.
- AsyncTask에는 사전 실행, 게시 시 백그라운드에서 실행하는 추상적인 방법이 있습니다.실행
- DoInBackground는 WorkerThread입니다(UI를 업데이트할 수 없음).
- PreExecute가 메인 스레드인 경우
- PostExecute가 MainThread인 경우(UI를 업데이트할 수 있음)
예
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
mEmailView = (AutoCompleteTextView) findViewById(R.id.email);
AsyncTask<Void, Void, Post> asyncTask = new AsyncTask<Void, Void, Post>() {
@Override
protected Post doInBackground(Void... params) {
try {
ApiClient defaultClient = Configuration.getDefaultApiClient();
String authorization = "eyJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoxLCJleHAiOjE1ODIxMzM4MTB9.bA3Byc_SuB6jzqUGAY4Pyt4oBNg0VfDRctZ8-PcPlYg"; // String | JWT token for Authorization
ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
Bearer.setApiKey(authorization);
PostApi apiInstance = new PostApi();
String id = "1"; // String | id
Integer commentPage = 1; // Integer | Page number for Comment
Integer commentPer = 10; // Integer | Per page number For Comment
Post result;
try {
result = apiInstance.apiV1PostsIdGet(id, authorization, commentPage, commentPer);
} catch (ApiException e) {
e.printStackTrace();
result = new Post();
}
return result;
} catch (Exception e) {
e.printStackTrace();
return new Post();
}
}
@Override
protected void onPostExecute(Post post) {
super.onPostExecute(post);
if (post != null) {
mEmailView.setText(post.getBody());
System.out.print(post);
}
}
};
asyncTask.execute();
}
아래와 같이 코드를 변경합니다.
@Override
protected void onPostExecute(String result) {
runOnUiThread(new Runnable() {
public void run() {
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");
}
});
}
언급URL : https://stackoverflow.com/questions/9671546/asynctask-android-example
반응형
'programing' 카테고리의 다른 글
| 여러 단계 항목에 대한 치명적인 오류 발생 (0) | 2023.07.10 |
|---|---|
| 읽기 전용 스냅샷 VS 스냅샷 분리 수준 (0) | 2023.07.10 |
| IPA 재서명(iPhone) (0) | 2023.07.05 |
| 레이저 뷰 엔진이 장착된 ASP.NET MVC 3의 부분 뷰에서 특정 섹션으로 컨텐츠 주입 (0) | 2023.07.05 |
| Python 스크립트가 실행을 완료하는 데 소요된 시간 확인 (0) | 2023.07.05 |