Android：如何从AsyncTask调用活动的非静态方法（通过doInBackground）

我有一个

类

，负责执行后台任务

public class BackgroundTask extends AsyncTask<Void, Void, Void>
{
    private ProgressDialog dialog;

    public BackgroundTask(AppCompatActivity activity)
    {
        dialog = new ProgressDialog(activity);
    }

    @Override
    protected void onPreExecute()
    {
        dialog.setMessage("Doing something, please wait.");
        dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        dialog.setCancelable(false);
        dialog.setProgress(0);
        dialog.setMax(100);
        dialog.show();
    }

    @Override
    protected void onPostExecute(Void result)
    {
        if (dialog.isShowing())
        {
            dialog.dismiss();
        }
    }

    @Override
    protected Void doInBackground(Void... params)
    {
        try
        {
            // How can I call non-static method of MyActivity here?
        }
        catch (InterruptedException e) 
        {
            e.printStackTrace();
        }

        return null;
    }
}

然后在对话框中显示等待的动画，这非常好。我想知道：我如何将属于

MyActivity

（以及任何其他活动）的非静态方法（消耗时间）传递给这个

背景任务
，以便我可以从“doInBackground”调用它

提前谢谢

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

    private ProgressDialog dialog;
    private MyActivity activity;

    public BackgroundTask(MyActivity activity) {
        this.activity = activity;
        dialog = new ProgressDialog(activity);
    }

    ...    

    @Override
    protected Void doInBackground(Void... params) {
        try {
            activity.callWhatYouNeed();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return null;
    }
}

扩展自
BaseActivity
：

public class MyActivity extends BaseActivity {

    @Override
    public void callWhatYouNeed() {
         //Implementation
    }

}

并更改任务

public class BackgroundTask extends AsyncTask<Void, Void, Void>
{
    private ProgressDialog dialog;
    private BaseActivity activity;

    public BackgroundTask(BaseActivity activity)
    {
        this.activity = activity;
        dialog = new ProgressDialog(activity);
    }

    @Override
    protected Void doInBackground(Void... params) {
        try {
            activity.callWhatYouNeed();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

公共类BackgroundTask扩展了AsyncTask
{
私人对话；
私人活动；
公共背景任务（基本活动）
{
这个。活动=活动；
dialog=新建进度对话框（活动）；
}
@凌驾
受保护的Void doInBackground（Void…参数）{
试一试{
activity.callWhatyYouneed（）；
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回null；
}
}

或者您可以使用instanceof运算符检查活动：

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

    private ProgressDialog dialog;
    private AppCompatActivity activity;

    public BackgroundTask(AppCompatActivity activity) {
        this.activity = activity;
        dialog = new ProgressDialog(activity);
    }

    ...

    @Override
    protected Void doInBackground(Void... params){
        try {
            if (activity instanceof MyActivity) {
                ((MyActivity) activity).callWhatYouNeed();
            } else if (acitivty instanceof SeocndActivity) {
                ((SecondActivity) activity).secondCall();
            }
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }

        return null;
    }
}

公共类BackgroundTask扩展了AsyncTask{
私人对话；
私人活动；
公共背景任务（AppCompatActivity活动）{
这个。活动=活动；
dialog=新建进度对话框（活动）；
}
...
@凌驾
受保护的Void doInBackground（Void…参数）{
试一试{
if（MyActivity的活动实例）{
（（MyActivity）activity.callWhatYouNeed（）；
}else if（SeocndActivity的活动实例）{
（（SecondActivity）activity.secondCall（）；
}
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回null；
}
}

但是使用instanceof是一种不好的做法，所以我强烈建议使用继承

 BackgroundTask task = new BackgroundTask(MyActivity.this);
 task.execute();

扩展自
BaseActivity
：

public class MyActivity extends BaseActivity {

    @Override
    public void callWhatYouNeed() {
         //Implementation
    }

}

并更改任务

public class BackgroundTask extends AsyncTask<Void, Void, Void>
{
    private ProgressDialog dialog;
    private BaseActivity activity;

    public BackgroundTask(BaseActivity activity)
    {
        this.activity = activity;
        dialog = new ProgressDialog(activity);
    }

    @Override
    protected Void doInBackground(Void... params) {
        try {
            activity.callWhatYouNeed();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

公共类BackgroundTask扩展了AsyncTask
{
私人对话；
私人活动；
公共背景任务（基本活动）
{
这个。活动=活动；
dialog=新建进度对话框（活动）；
}
@凌驾
受保护的Void doInBackground（Void…参数）{
试一试{
activity.callWhatyYouneed（）；
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回null；
}
}

或者您可以使用instanceof运算符检查活动：

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

    private ProgressDialog dialog;
    private AppCompatActivity activity;

    public BackgroundTask(AppCompatActivity activity) {
        this.activity = activity;
        dialog = new ProgressDialog(activity);
    }

    ...

    @Override
    protected Void doInBackground(Void... params){
        try {
            if (activity instanceof MyActivity) {
                ((MyActivity) activity).callWhatYouNeed();
            } else if (acitivty instanceof SeocndActivity) {
                ((SecondActivity) activity).secondCall();
            }
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }

        return null;
    }
}

公共类BackgroundTask扩展了AsyncTask{
私人对话；
私人活动；
公共背景任务（AppCompatActivity活动）{
这个。活动=活动；
dialog=新建进度对话框（活动）；
}
...
@凌驾
受保护的Void doInBackground（Void…参数）{
试一试{
if（MyActivity的活动实例）{
（（MyActivity）activity.callWhatYouNeed（）；
}else if（SeocndActivity的活动实例）{
（（SecondActivity）activity.secondCall（）；
}
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回null；
}
}

但是使用instanceof是一种不好的做法，所以我强烈建议使用继承

 BackgroundTask task = new BackgroundTask(MyActivity.this);
 task.execute();

当您在MyActivity类中调用上述代码时，您已经在构造函数中传递了类上的实例。因此，您可以从MyActivity类获得任何非静态方法。比如说

    public class BackgroundTask extends AsyncTask<Void, Void, Void>{
    private ProgressDialog dialog;

    private MyActivity activity;

public BackgroundTask(MyActivity activity)
{
    this.activity = activity;
    dialog = new ProgressDialog(activity);
}

@Override
protected void onPreExecute()
{
    dialog.setMessage("Doing something, please wait.");
    dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
    dialog.setCancelable(false);
    dialog.setProgress(0);
    dialog.setMax(100);
    dialog.show();
}

@Override
protected void onPostExecute(Void result)
{
    if (dialog.isShowing())
    {
        dialog.dismiss();
    }
}

@Override
protected Void doInBackground(Void... params)
{
    try
    {
      activity.callyourmethod();

    }
    catch (InterruptedException e) 
    {
        e.printStackTrace();
    }

    return null;
}

公共类BackgroundTask扩展了AsyncTask{
私人对话；
私人活动；
公共背景任务（MyActivity活动）
{
这个。活动=活动；
dialog=新建进度对话框（活动）；
}
@凌驾
受保护的void onPreExecute（）
{
setMessage（“正在做某事，请稍候”）；
setProgressStyle（ProgressDialog.STYLE_微调器）；
对话框。可设置可取消（false）；
对话框。设置进度（0）；
dialog.setMax（100）；
dialog.show（）；
}
@凌驾
受保护的void onPostExecute（void结果）
{
if（dialog.isShowing（））
{
dialog.dismise（）；
}
}
@凌驾
受保护的Void doInBackground（Void…参数）
{
尝试
{
activity.callyourmethod（）；
}
捕捉（中断异常e）
{
e、 printStackTrace（）；
}
返回null；
}

}

当您在MyActivity类中调用上述代码时，您已经在构造函数中传递了类上的实例。因此，您可以从MyActivity类获得任何非静态方法。比如说

    public class BackgroundTask extends AsyncTask<Void, Void, Void>{
    private ProgressDialog dialog;

    private MyActivity activity;

public BackgroundTask(MyActivity activity)
{
    this.activity = activity;
    dialog = new ProgressDialog(activity);
}

@Override
protected void onPreExecute()
{
    dialog.setMessage("Doing something, please wait.");
    dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
    dialog.setCancelable(false);
    dialog.setProgress(0);
    dialog.setMax(100);
    dialog.show();
}

@Override
protected void onPostExecute(Void result)
{
    if (dialog.isShowing())
    {
        dialog.dismiss();
    }
}

@Override
protected Void doInBackground(Void... params)
{
    try
    {
      activity.callyourmethod();

    }
    catch (InterruptedException e) 
    {
        e.printStackTrace();
    }

    return null;
}

公共类BackgroundTask扩展了AsyncTask{
私人对话；
私人活动；
公共背景任务（MyActivity活动）
{
这个。活动=活动；
dialog=新建进度对话框（活动）；
}
@凌驾
受保护的void onPreExecute（）
{
setMessage（“正在做某事，请稍候”）；
setProgressStyle（ProgressDialog.STYLE_微调器）；
对话框。可设置可取消（false）；
对话框。设置进度（0）；
dialog.setMax（100）；
dialog.show（）；
}
@凌驾
受保护的void onPostExecute（void结果）
{
if（dialog.isShowing（））
{
dialog.dismise（）；
}
}
@凌驾
受保护的Void doInBackground（Void…参数）
{
尝试
{
activity.callyourmethod（）；
}
捕捉（中断异常e）
{
e、 printStackTrace（）；
}
返回null；
}

}
这将只与
MyActivity
绑定。然而，本课程也将用于进行其他活动的背景活动。因此，我正在寻找从任何活动调用的方法。从一些
BaseActivity
派生活动（需要等待）是一个不错的选择。谢谢这个会泄漏吗？如果是这样，异步任务上的最佳活动是否应该在WeakReference中处理