implement - hilos asynctask android

AsyncTask-Devuelve una cadena en postExecute a la actividad, que inició la tarea asíncrona sin bloquear el subproceso de interfaz de usuario

Question

Tengo una actividad, que inicia una AsyncTask con un diálogo de proceso implementado. Eso funciona bien! Pero quiero obtener un retorno de cadena cuando la tarea asyncTask ha terminado. Así que tengo que devolver algo en el onPostExecute - Método. Ese resultado (cadena) quiero capturar en la Actividad, que comenzó la AsyncTask. No quiero usar .get () porque bloquea el hilo de UI.

¿Qué debo escribir en onPostExecute y la Actividad tomar la cadena de doInBackground?

Gracias por cualquier tipo de ayuda para resolver este problema;)

Ahora con el código:

class BgDL extends AsyncTask<String, Integer, String> {
String finishString="";
private Context context;
ProgressDialog pdialog;
public BgDL(Context cxt) { //get the context (usually "this" from Activity / otherwise progressdialog wont show up!
context = cxt;
pdialog = new ProgressDialog(context);
}
@Override
protected String doInBackground(String... strings) {
OutputStream output;
ByteArrayOutputStream baos = null;
try {
URL url = new URL(strings[0]);
URLConnection connection = url.openConnection();
connection.connect();
int fileLength = connection.getContentLength();
InputStream input = new BufferedInputStream(url.openStream());
if (strings[1]=="toString") { // write byte to string if a file is not given
baos= new ByteArrayOutputStream();
output = new DataOutputStream(baos);
} else { //otherwise to string
output = new FileOutputStream(strings[1]);
}
byte data[] = new byte[1024];
long total = 0;
int count;
while ((count = input.read(data)) != -1) {
total += count;
publishProgress((int) (total * 100 / fileLength));
output.write(data, 0, count);
}
output.flush();
output.close();
input.close();
if (strings[1]=="toString") {
finishString = baos.toString(); //
} // only write byte to string if a file is not given
} catch (Exception e) {log.d("ex",e.toString());
}
return finishString;
}
@Override
protected void onPreExecute() {
super.onPreExecute();
pdialog.setTitle("Please wait");
pdialog.setIndeterminate(false);
pdialog.setMax(100);
pdialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
pdialog.show();
}
@Override
protected void onProgressUpdate(Integer... progress) {
super.onProgressUpdate(progress);
pdialog.setProgress(progress[0]);
}
protected void onPostExecute(String...finishString) {
pdialog.dismiss();//!!!!!!!!!finishString i want to pass over to my Activity, which started this asynctask with .execute();
}

Answer 1

¿Qué debo escribir en onPostExecute y la Actividad tomar la cadena de doInBackground?

Cuando usa AsyncTask , puede actualizar su UI solo en los onProgressUpdate y onPostExecute .

Su método doInBackground() devuelve algunos datos y estos datos van al método onPostExecute (también depende de cómo se declaran sus genéricos).

Generalmente, no hay otro acerca de cómo hacerlo.

Querías decir esto:

AsyncTask a = new AsyncTask(Context);
a.execute(Input);

Primero significa que su constructor se parece a

public MyAsync(Context c) {
this.c = c;
}

En segundo lugar significa que ha declarado su primer tipo genérico (suposición Parámetro de entrada es String ) como

private class MyAsync extends AsyncTask<String, Void, String> {
//...
}

Y desea actualizar la UI con String que devuelve el método doInBackground() y simplemente colocar el método onPostExecute con el parámetro IN String que devuelve doInBackground() .

protected void onPostExecute(String stringReturnedFromDoInBackground)
{
// some work
}

Entonces, si desea hacerlo de otra manera, cambie la lógica de su aplicación y utilice, por ejemplo, ResultReceiver con IntentService .

Answer 2

El valor de retorno de doInBackground () es formal en onPostExecute (). Entonces deberías poder pasarlo.

Answer 3

Cree una clase en su proyecto que amplíe la actividad como se muestra a continuación:

public class SomeClass extends Activity
{
public void dataFromPostExecute(String data)
{
System.out.println("in mainactivity");
}
}

Si quieres un hilo único para cada actividad, simplemente crea una clase que extienda la aplicación

public class Async extends Application
{
private Socket globalSocket;
@Override
public void onCreate()
{
//socket = null;
}
public Socket getglobalSocket()
{
return globalSocket;
}
public void setGlobalSocket(Socket globalSocket)
{
this.globalSocket = globalSocket;
}
}

En su clase de socket que extiende Asynctask haga lo siguiente:

public SocketClass extends AsyncTask<String,String,String>
{
Async app;
private SomeClass t_act;
public SocketClass(SomeClass sct)
{
t_act = sct;
this.con = tst;
app= ((Async)sct.getApplicationContext());
}
protected void onPostExecute(String data)
{
t_act.dataFromPostExecute(data);
}
}

Luego, en su actividad extienda SomeClass y haga lo siguiente:

public class Activity1 extends SomeClass
{
public void dataFromPostExecute(String data)
{
//do whatever you want. "data" of this method contains the values from
postexecute()
}
}