Question

在现有应用程序中，我有一个带有内部类的活动，它扩展了AsyncTask，如下所示：

public class Activity_1 extends BaseActivity {
    ....
    new async().execute();
    ...

    public class asyncextends AsyncTask<Void, Void, String> {
        protected String doInBackground(Void... progress) { ... }
        protected void onPreExecute() { ... }
        protected void onPostExecute(String result) { ... }
    }
}

现在，我需要从另一个活动调用相同的doInBackground方法，但是这个内部类的onPostExecute()在一些本地UI变量上运行，因此不可能在clas之外使用它。有没有什么方法可以调用这个AsyncTask，只是覆盖onPostExecute和onPreExecute - 方法，或者我应该在另一个活动中创建另一个内部类，做同样的背景事情（当然把它移到普通的实用类或其他东西）等......？

Answer 1

您可以创建单独的抽象包私有类，扩展AsyncTask并实现doInBackground()方法：

abstract class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    final protected String doInBackground(Void... progress) { 
        // do stuff, common to both activities in here
    }
}

在您的活动中，只是继承MyAsyncTask（顺便说一句，新课可能应该是私有的），实施onPostExecute()和onPreExecute()方法：

public class Activity_1 extends BaseActivity {

    ...
    new Async1().execute();
    ...

    private class Async1 extends MyAsyncTask {
        @Override
        protected void onPreExecute(){ 
            // Activity 1 GUI stuff
        }

        @Override
        protected void onPostExecute(String result) {
            // Activity 1 GUI stuff
        }
    }
}

如果onPreExecute和onPostExecute也包含一些常见操作，您可以应用以下模式：

abstract class MyAsyncTask extends AsyncTask<Void, Void, String> {
    public interface MyAsyncTaskListener {
       void onPreExecuteConcluded();
       void onPostExecuteConcluded(String result);  
    }

    private MyAsyncTaskListener mListener;

    final public void setListener(MyAsyncTaskListener listener) {
       mListener = listener;
    }

    @Override
    final protected String doInBackground(Void... progress) { 
        // do stuff, common to both activities in here
    }

    @Override
    final protected void onPreExecute() {
        // common stuff
        ...
        if (mListener != null) 
            mListener.onPreExecuteConcluded();
    }

    @Override
    final protected void onPostExecute(String result) {
        // common stuff
        ...
        if (mListener != null) 
            mListener.onPostExecuteConcluded(result);
    }
}

并在您的活动中使用它，如下所示：

public class Activity_1 extends BaseActivity {

    ...
    MyAsyncTask aTask = new MyAsyncTask();
    aTask.setListener(new MyAsyncTask.MyAsyncTaskListener() {
       @Override
       void onPreExecuteConcluded() {
           // gui stuff
       }

       @Override
       void onPostExecuteConcluded(String result) {
           // gui stuff
       }
    });
    aTask.execute();
    ...
}

您也可以使用Activity工具MyAsyncTaskListener：

public class Activity_1 extends BaseActivity implements MyAsyncTask.MyAsyncTaskListener {
    @Override
    void onPreExecuteConcluded() {
        // gui stuff
    }

    @Override
    void onPostExecuteConcluded(String result) {
       // gui stuff
    }

    ...
    MyAsyncTask aTask = new MyAsyncTask();
    aTask.setListener(this);
    aTask.execute();
    ...

}

我从头开始编写代码，因此它可能包含错误，但它应该说明这个想法。

Answer 2

它如此简单只需构建一个主类的对象，然后像这样调用内部类

 OuterMainClass outer = new OuterMainClass();
       outer.new InnerAsyncClass(param)
         .execute();

这个答案为时已晚，无法帮助你，但希望能帮到别人。

由于

Answer 3

1.在ClassOne中创建AsynckTask的构造函数。

2.通过新关键字创建对象或ClassOne。

3.按对象调用异步任务

ClassOne{

class AsyncParmas extends AsyncTask {

        public ADDloadGeofenceDetails() {
        }

        @Override
        protected void onPreExecute() {


            super.onPreExecute();
        }

        @Override
        protected Object doInBackground(Object... params) {

}
}

Class ClassTwo{
ClassOne obj= new ClassOne ();

                    obj.new AsyncParmas ().execute();
}
}

GoodLuck谁面临问题。

Answer 4

如果我们在一个类中创建一个静态方法，并且将在AsyncTask的doInBackground中的任何类中执行，我们可以轻松地通过同一个类甚至在不同的类中更新UI。

从另一个类调用AsyncTask

4 个答案: