publishProgress à partir de l'intérieur d'une fonction dans doInBackground?

Une solution pourrait être de placer un simple public de classe à l'intérieur de l'AsyncTask (assurez-vous que la tâche que vous définissez est également public) qui a un public méthode qui appelle publishProgress(val). En passant cette classe devrait être disponible à partir de n'importe quel autre paquet ou de la classe.

public abstract class MyClass {

    public MyClass() {
        //code...
    }

    //more code from your class...

    public class Task extends AsyncTask<String, Integer, Integer> {
        private Progress progress;

        protected Task() {
            this.progress = new Progress(this);
        }

        //...

        @Override
        protected Integer doInBackground(String... params) {
            //...
            SomeClass.doStuff(progress);
            //...
        }

        //...

        @Override
        protected void onProgressUpdate(Integer... progress) {
            //your code to update progress
        }

        public class Progress {
            private Task task;

            public Progress(Task task) {
                this.task = task;
            }

            public void publish(int val) {
                task.publishProgress(val);
            }
        }
    }
}

puis dans l'autre classe:

public class SomeClass {
    public static void doStuff(Progress progress){
        //do stuff
        progress.publish(20);
        //more stuff etc
    }
}

Cela a fonctionné pour moi.

Si cela fonctionne s'il vous plaît laissez-moi savoir! Noter que l'appel doProgress à partir de n'importe où d'autre qu'une méthode qui a été appelé à partir de doInBackground va certainement causer une erreur.

Oui, il fonctionne. J'ai prolongé de sorte que vous n'avez pas besoin de passer l'AsyncTask en tant que paramètre à la méthode. Ceci est particulièrement utile si (comme moi) vous avez déjà écrit toutes vos méthodes avant de décider qu'en fait, vous ne devez publier quelques progrès, ou dans mon cas, la mise à jour de l'INTERFACE utilisateur à partir d'un AsyncTask:

public abstract class ModifiedAsyncTask<A,B,C> extends AsyncTask<A,B,C>{
private static final HashMap<Thread,ModifiedAsyncTask<?,?,?>> threads 
= new HashMap<Thread,ModifiedAsyncTask<?,?,?>>();
@Override
protected C doInBackground(A... params) {
threads.put(Thread.currentThread(), this);
return null;        
}
public static <T> void publishProgressCustom(T... t) throws ClassCastException{
ModifiedAsyncTask<?, T, ?> task = null;
try{
task = (ModifiedAsyncTask<?, T, ?>) threads.get(Thread.currentThread());
}catch(ClassCastException e){
throw e;
}
if(task!=null)
task.publishProgress(t);
}
}
public class testThreadsActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);        
}
public void Button1Clicked(View v){
MyThread mthread = new MyThread();
mthread.execute((Void[])null);      
}
private class MyThread extends ModifiedAsyncTask<Void, Long, Void>{
@Override
protected Void doInBackground(Void... params) {
super.doInBackground(params);
while(true){
myMethod(System.currentTimeMillis());               
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {                  
return null;
}
}           
}
protected void onProgressUpdate(Long... progress) {
//Update UI
((TextView) findViewById(R.id.textView2)).setText("The Time is:" + progress[0]);
}
}
private void myMethod(long l){
//do something
//request UI update
ModifiedAsyncTask.publishProgressCustom(new Long[]{l});
}
}

Se sent assez sale pour moi, quelqu'un d'autre a une meilleure façon?

Ma façon de procéder est probablement pire. Je suis d'appeler une méthode statique pour doProgress (que j'ai appelée publishProgressCustom). Elle peut être appelée à partir de n'importe où, sans produire une erreur (comme si le fil n'a pas de correspondant AsyncTask dans la table de hachage, il ne fera pas appel publishProgress). L'inconvénient est que vous devez ajouter le Fil d'AsyncTask cartographie de vous-même après que le thread a commencé. (Vous ne pouvez pas remplacer AsyncTask.execute() malheureusement, comme c'est définitif). Je l'ai fait ici, en substituant doInBackground() dans la classe supérieure, de sorte que quiconque, l'extension, il suffit de le mettre super.doInBackground() la première ligne dans leur propre doInBackground().

Je ne sais pas assez sur les Threads et les AsyncTask pour savoir ce qui se passe à la table de hachage références une fois le Fil et/ou AsyncTask vient à une fin. Je soupçonne que de mauvaises choses arrivent, donc je ne dirais pas que quiconque essayer ma solution dans le cadre de leur propre, à moins qu'ils savent mieux