Llamar AsyncTask de otra clase

En una aplicación existente tengo una actividad con una clase interna que extiende AsyncTask, esto se parece a lo siguiente:

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) { ... } } }

Ahora, necesito llamar al mismo método doInBackground de otra actividad, pero el onPostExecute() de esta clase interna opera en algunas variables locales de IU y por lo tanto no es posible usarlo desde fuera del clas. ¿Hay alguna manera que puedo llamar a este AsyncTask, y sólo anular el onPostExecute y onPreExecute , o debo crear otra inner-class en la otra actividad, hacer la misma cosa de fondo (por supuesto, pasar a la clase de utilidad común o Algo), etc …?

Puede crear una clase privada de paquete abstracto separada, extendiendo AsyncTask y aplicando el método doInBackground() :

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

Y en sus actividades simplemente heredar de MyAsyncTask (la nueva clase probablemente debería ser privada, por cierto), la implementación de onPostExecute() y 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 } } }

Si onPreExecute y onPostExecute contienen también algunas acciones comunes, puede aplicar el siguiente patrón:

 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); } }

Y utilizarlo en su actividad como sigue:

 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(); ... }

También puede tener su Activity implementar MyAsyncTaskListener también:

 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(); ... }

Escribí el código de la cabeza, por lo que podría contener errores, pero debe ilustrar la idea.

Su tan simple Simplemente construir un objeto de clase principal y que llamar a la clase interna como este

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

Esta respuesta es demasiado tarde para ayudarte, pero espero que ayude a otros.

Gracias

Si creamos un método estático que está en una clase y que se ejecutará en cualquier clase en doInBackground de AsyncTask podemos actualizar fácilmente la interfaz de usuario a través de la misma clase e incluso en diferentes clases.