从Android中的AsyncTask返回一个值[重复]

Question

一个简单的问题：是否可以在AsyncTask 中返回一个值？

//AsyncTask is a member class
private class MyTask extends AsyncTask<Void, Void, Void>{

    protected Void doInBackground(Void... params) {
         //do stuff
         return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        //do stuff
        //how to return a value to the calling method?
    }
}

然后在我的Activity/Fragment:

// The task is started from activity
myTask.execute()
// something like this?
myvalue = myTask.getvalue() 

编辑： 很久以前有人问过我对Java不熟悉的地方，现在我对它更好，我将做一个简短的总结：

异步任务的重点是任务是asynchronous，意思是你在任务上调用execute()后，任务开始在自己的线程上运行。从 asynctask 返回一个值是没有意义的，因为原来的调用线程已经在做其他事情（因此任务是异步的）。

想想时间： 在某个时间点，您启动了一项将与主线程并行运行的任务。当并行运行的任务完成时，主线程上的时间也过去了。并行任务无法及时返回给主线程返回值。

我来自 C 语言，所以我对此知之甚少。但似乎很多人都有同样的问题，所以我想我会澄清一下。

Answer 1

您需要使用"protocols"来委托或提供数据给AsynTask。

委托和数据源

委托是一个对象，当另一个对象遇到程序中的事件时，它代表另一个对象或与之协调。 (Apple definition)

协议是定义一些方法来委托某些行为的接口。

---

DELEGATE：在后台线程中从对象中捕获事件

---

异步任务：

public final class TaskWithDelegate extends AsyncTask<..., ..., ...> {
    //declare a delegate with type of protocol declared in this task
    private TaskDelegate delegate;

    //here is the task protocol to can delegate on other object
    public interface TaskDelegate {
        //define you method headers to override
        void onTaskEndWithResult(int success);
        void onTaskFinishGettingData(Data result);
    }

    @Override
    protected Integer doInBackground(Object... params) {
        //do something in background and get result
        if (delegate != null) {
            //return result to activity
            delegate.onTaskFinishGettingData(result);
        }   
    }

    @Override
    protected void onPostExecute(Integer result) {
        if (delegate != null) {
            //return success or fail to activity
            delegate.onTaskEndWithResult(result);
        }   
    }
}

活动：

public class DelegateActivity extends Activity implements TaskDelegate {
    void callTask () {
            TaskWithDelegate task = new TaskWithDelegate;
        //set the delegate of the task as this activity
        task.setDelegate(this);
    }

    //handle success or fail to show an alert...
    @Override
    void onTaskEndWithResult(int success) {

    }

    //handle data to show them in activity...
    @Override
    void onTaskFinishGettingData(Data result) {

    }
}

---

编辑：如果您在 doInBackground 中调用委托，并且委托尝试编辑某些视图，则会崩溃，因为视图只能由主线程操作。

---

// this refers to Activity
this.runOnUiThread(new Runnable() {
    @Override
    public void run() {
    // Here you can edit views when task notify some changes from background thread
        textView.setText(someValue);
    }
});

---

额外

DATASOURCE：在后台线程中向对象提供数据

---

异步任务：

public final class TaskWithDataSource extends AsyncTask<..., ..., ...> {
    //declare a datasource with type of protocol declared in this task
    private TaskDataSource dataSource;
    private Object data;

    //here is the task protocol to can provide data from other object
    public interface TaskDataSource {
        //define you method headers to override
        int indexOfObject(Object object);
        Object objectAtIndex(int index);
    }

    @Override
    protected void onPreExecute(Integer result) {
        if (dataSource != null) {
            //ask for some data
            this.data = dataSource.objectAtIndex(0);
        }   
    }

    @Override
    protected Integer doInBackground(Object... params) {
        //do something in background and get result
        int index;
        if (dataSource != null) {
            //ask for something more
            index = dataSource.indexOfObject(this.data);
        }   
    }
}

活动：

public class DataSourceActivity extends Activity implements TaskDataSource {
    void callTask () {
            TaskWithDataSource task = new TaskWithDataSource;
        //set the datasource of the task as this activity
        task.setDataSource(this);
    }

    //send some data to the async task when it is needed...
    @Override
    Object objectAtIndex(int index) {
        return new Data(index);
    }

    //send more information...
    @Override
    int indexOfObject(Object object) {
        return new object.getIndex();
    }
}

Answer 2

代码示例：Activity使用AsyncTask在后台线程中获取值，然后AsyncTask通过调用processValue将结果返回给Activity：

public class MyClass extends Activity {
  private void getValue() {
      new MyTask().execute();
  }

  void processValue(Value myValue) {
     //handle value 
     //Update GUI, show toast, etc..
  }

  private class MyTask extends AsyncTask<Void, Void, Value> {
    @Override
    protected Value doInBackground(Void... params) {
      //do stuff and return the value you want 
      return Value;
    }

    @Override
    protected void onPostExecute(Value result) {
      // Call activity method with results
      processValue(result);
    }
  }
}

Answer 3

对于您从 AsyncTask 获取结果，它需要在 super.onPostExcecute(result) 之后执行； 因为这意味着后台和AsyncTask也已经完成了。 例如：

... into your async task

@Override
protected void onPostExecute(MyBeanResult result) {
    if (dialog.isShowing()) {
        dialog.dismiss();
    }
    if (mWakeLock.isHeld()) {
        mWakeLock.release();
    }
    super.onPostExecute(result);
    MyClassName.this.checkResponseForIntent(result);
}

方法器 checkResponseForIntent 可能是这样的：

private void checkResponseForIntent(MyBeanResult response) {
    if (response == null || response.fault != null) {
        noServiceAvailable();
        return;
    }
 ... or do what ever you want, even call an other async task...

我在使用 AsyncTask 中的 .get() 时遇到了这个问题，而 ProgressBar 根本不适用于 get()，实际上，它只有在 doInBackground 完成后才有效。

希望对你有帮助。

Answer 4

使用泛型参数

AsyncTask<Params, Progress, Result>

• Params — 任务的输入数据类型
• Progress — 如何向全世界通报进展
• Result — 任务的输出数据类型

想想

Result = task(Params)

示例

通过字符串 URL 加载 YourObject：

new AsyncTask<String, Void, YourObject>()
{
    @Override
    protected void onPreExecute()
    {
        /* Called before task execution; from UI thread, so you can access your widgets */

        // Optionally do some stuff like showing progress bar
    };

    @Override
    protected YourObject doInBackground(String... url)
    {
        /* Called from background thread, so you're NOT allowed to interact with UI */

        // Perform heavy task to get YourObject by string
        // Stay clear & functional, just convert input to output and return it
        YourObject result = callTheServer(url);
        return result;
    }

    @Override
    protected void onPostExecute(YourObject result)
    {
        /* Called once task is done; from UI thread, so you can access your widgets */

        // Process result as you like
    }
}.execute("http://www.example.com/");

Answer 5

将 MainActivity 传递给 Async 类，因此您将在内部类中访问 MainActivity 函数， 这对我来说很好：

public class MainActivity extends ActionBarActivity {

   void callAsync()
   {
      Async as = new Async(this,12,"Test");
      as.execute();
   }

   public void ReturnThreadResult(YourObject result)
   {
     // TO DO:
     // print(result.toString());

   }
}


public class Async extends AsyncTask<String, String, Boolean> {
    MainActivity parent;
    int param1;
    String param2;

    public Async(MainActivity parent,int param1,String param2){
       this.parent = parent;
       this.param1 = param1;
       this.param2 = param2;
    }

    @Override
    protected void onPreExecute(){};

    @Override
    protected YourObject doInBackground(String... url)
    {
        return result;
    }

    @Override
    protected void onPostExecute(YourObject result)
    {
       // call an external function as a result 
       parent.ReturnThreadResult(result);
    }
  }  

Answer 6

为什么不调用处理值的方法？

public class MyClass extends Activity {

    private class myTask extends AsyncTask<Void, Void, Void> {

        //initiate vars
        public myTask() {
            super();
            //my params here
        }

        protected Void doInBackground(Void... params) {
            //do stuff
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            //do stuff
            myMethod(myValue);
        }
    }

    private myHandledValueType myMethod(Value myValue) {
        //handle value 
        return myHandledValueType;
    }
}

Answer 7

你可以试试这个：myvalue = new myTask().execute().get(); 减号是它会冻结进程，直到异步不会完成；

Answer 8

最简单的方法是将调用对象传递给异步任务（如果你愿意，在构造它时）：

public class AsyncGetUserImagesTask extends AsyncTask<Void, Void, Void> {

    private MyImagesPagerFragment mimagesPagerFragment;
    private ArrayList<ImageData> mImages = new ArrayList<ImageData>();

    public AsyncGetUserImagesTask(MyImagesPagerFragment imagesPagerFragment) {
        this.mimagesPagerFragment = imagesPagerFragment;
    }

    @Override
    public Void doInBackground(Void... records) {
        // do work here
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        mimagesPagerFragment.updateAdapter(mImages);
    }
}

并且在调用类（你的activity或fragment）中执行任务：

public class MyImagesPagerFragment extends Fragment {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        AsyncGetUserImagesTask mGetImagesTask = new AsyncGetUserImagesTask(this);
        mGetImagesTask.execute();
    }

然后 onPostExecuteMethod 将调用您喜欢的原始类的任何方法，例如：

    public void updateAdapter(List<ImageData> images) {
        mImageAdapter.setImages(images);
        mImageAdapter.notifyDataSetChanged();
    }
}

Answer 9

这就是onPostExecute() 的用途。它在 UI 线程上运行，您可以将结果从那里传送到屏幕（或您需要的任何其他地方）。在最终结果可用之前不会调用它。如果您想提供中间结果，请查看onProgressUpdate()