Java AsyncTask中doBackgorund中共享类的发布进度

我有几个不同的

AsyncTasks

，它们需要执行相同的共享基本操作，并在执行过程中显示进度。有没有办法通过传入另一个类来共享代码，而不是多次复制大量代码（每次都显示进度）？

AsyncTasks

是非常不同的，您不能只传递摘要，因为它有一个受保护的

publishProgress（）

方法。看了很多例子，尝试了很多不同的变化，但都没有成功

下面是详细信息……假设我们有两个不同的任务，做不同的事情，但需要访问服务器，下载一些文件，然后将它们放入数据库（然后做其他事情）：

公共类ExampleTaskFragment扩展了ListFragment{
私人进程；
私有void hideProgress（）{
mProgress.disclose（）；
}
私有void showProgress（字符串消息）{
mProgress=ProgressDialog.show（getActivity（），null，message，true，false）；
}
受保护的void updateProgressMessage（字符串消息）{
mProgress.setMessage（消息）；
}
公共类TaskA扩展了异步任务{
public void progressUpdate（字符串…值）{
出版进度（价值观）；
}
@凌驾
受保护的void onCancelled（）{
hideProgress（）；
}
@凌驾
受保护的void onPreExecute（）{
showProgress（“共享前的内容…”）；
}
@凌驾
受保护的ArrayList doInBackground（对象…参数）{
//DoStuffPublish是两个任务共享的常见内容
DoStuffPublish dostuff=新的DoStuffPublish（本）；
返回doMoreStuffA（）；
}
@凌驾
受保护的void onPostExecute（ArrayList结果）{
updateProgressMessage（“在共享内容之后…”）；
hideProgress（）；
}  
ArrayList doMoreStuffA（）{
返回新的ArrayList（）；
}
}
公共类TaskB扩展了异步任务{
public void progressUpdate（字符串…值）{
出版进度（价值观）；
}
@凌驾
受保护的void onCancelled（）{
hideProgress（）；
}
@凌驾
受保护的void onPreExecute（）{
showProgress（“共享前的内容…”）；
}
@凌驾
受保护的ArrayList doInBackground（对象…参数）{
//DoStuffPublish是两个任务共享的常见内容
DoStuffPublish dostuff=新的DoStuffPublish（本）；
返回doMoreStuffB（）；
}
@凌驾
受保护的void onPostExecute（ArrayList结果）{
updateProgressMessage（“在共享内容之后…”）；
hideProgress（）；
}  
ArrayList doMoreStuffB（）{
返回新的ArrayList（）；
}
}
}
公共类DoStuffPublish{
私有异步任务；
公共DoStuffPublish（异步任务）{
超级（）；
this.task=任务；
doSharedStuff（）；
}
受保护的void publishProgress（字符串消息）{
if（任务A的任务实例）{
（（任务A）任务）。进程更新（消息）；
}
else if（TaskB的任务实例）{
（（任务B）任务）。进程更新（消息）；
}
}
公共无效文件共享内容（）{
publishProgress（“做共享的东西…”）；
//在这里做很多分享的事情。。。
publishProgress（“完成共享内容…”）；
}
}

这段代码是拼凑而成的，所以不要太在意语法。这里的概念是…我希望有一个共享类，我可以调用2个或更多的任务来共享代码并发布更新。我尝试将ProgressDialog放入任务和外部，但没有成功。当我这样做时，我得到“只有创建视图层次结构的原始线程才能接触它的视图”。在调试器中，您可以看到两个不同的线程——原始主UI线程和以doInBackground（Object…params）形式创建的线程

---

我担心这可能是不可能的…

robinj-如果答案正确，只需要更好地阅读他/她的答案。诀窍是这样编码：`public class ExampleTaskFragment扩展了ListFragment{

private ProgressDialog mProgress;

private void hideProgress() {
    mProgress.dismiss();
}

private void showProgress(String message) {
    mProgress = ProgressDialog.show(getActivity(), null, message, true, false);
}

protected void updateProgressMessage(String message) {
    mProgress.setMessage(message);
}

public class TaskA extends AsyncTask<Object, String, ArrayList<A>> {

    public void progressUpdate(String... values) {
         publishProgress(values);
    }

    @Override
    protected void onProgressUpdate(String... values) {
        updateProgressMessage(values[0]);
    }
    @Override
     protected void onCancelled() {
          hideProgress();
     }
     @Override
     protected void onPreExecute() {
         showProgress("Stuff before shared...");
     }
     @Override
     protected ArrayList<A> doInBackground(Object... params) {

        // DoStuffPublish is the common stuff both tasks share
        DoStuffPublish dostuff = new DoStuffPublish(this);
        return doMoreStuffA();
     }

     @Override
     protected void onPostExecute(ArrayList<A> result) {
         updateProgressMessage("After shared stuff...");
         hideProgress();
     }  

     ArrayList<A> doMoreStuffA() {
        return new ArrayList<A>();
     }
}

public class TaskB extends AsyncTask<Object, String, ArrayList<B>> {

    public void progressUpdate(String... values) {
         publishProgress(values);
    }

    @Override
    protected void onProgressUpdate(String... values) {
        updateProgressMessage(values[0]);
    }

    @Override
     protected void onCancelled() {
          hideProgress();
     }
     @Override
     protected void onPreExecute() {
         showProgress("Stuff before shared...");
     }
     @Override
     protected ArrayList<B> doInBackground(Object... params) {

        // DoStuffPublish is the common stuff both tasks share
        DoStuffPublish dostuff = new DoStuffPublish(this);
        return doMoreStuffB();
     }

     @Override
     protected void onPostExecute(ArrayList<B> result) {
         updateProgressMessage("After shared stuff...");
         hideProgress();
     }  

     ArrayList<B> doMoreStuffB() {
        return new ArrayList<B>();
     }
}

} `

注意

    @Override
    protected void onProgressUpdate(String... values) {
        updateProgressMessage(values[0]);
    }

---

以前我一直试图直接设置mProgress值，但它在错误的线程中？无论如何，谢谢robinj的帮助！如果您输入答案，我会竖起大拇指…

听起来您需要实现一个任务管理器。听起来您试图在doInBackground（）中调用updateProgressMessage（），但它不起作用，因为它没有在UI线程中运行。我认为您需要重写AsyncTask.onProgressUpdate（）并在其中调用updateProgressMessage（），以便更新对话框以响应您对publishProgress（）的调用。有没有这样的示例可以实际使用？我尝试了大量不同的方法来实现这一点。robinj-我试图覆盖onProgressUpdate，但没有成功-也许我没有正确地实现它。如果你有这样一个例子，我将不胜感激！该代码实际上对

DoStuffPublish

实例没有任何作用，这只是从原始代码翻译的产物吗？我建议您将这段简化的代码放入一个实际的工作应用程序中，尽可能地反映您的真实代码。如果仍然不起作用，发布更新的代码，然后我们可以看到您实际运行的代码。现在我只是在猜测代码“拼凑”会导致什么问题，什么是真正的问题。如果这确实有效，请找出与实际应用程序的不同之处。

private AsyncTask task;

public DoStuffPublish(AsyncTask task) {
    super();
    this.task = task;
    doSharedStuff();
}

protected void publishProgress(String message) {
    if (task instanceof TaskA) {
        ((TaskA)task).progressUpdate(message);
    }
    else if (task instanceof TaskB) {
        ((TaskB)task).progressUpdate(message);
    }
}

public  void doSharedStuff() {

    publishProgress("Doing Shared stuff...");

    // Do lots of shared things here...

    publishProgress("Done doing shared stuff...");

 }

    @Override
    protected void onProgressUpdate(String... values) {
        updateProgressMessage(values[0]);
    }