Question

我有一个常见的异步任务类，它使用我的tcp客户端类启动tcp连接。我正在执行此主要活动时执行此异步任务，并将活动定义为调用者。这是我的异步类代码：

public class CommonAsyncTask extends AsyncTask<Handler,String,String> {

    OnAsyncRequestComplete caller;
    Context context;
    String m;
    List<NameValuePair> parameters = null;
    ProgressDialog pDialog = null;
    public TCPClient client;

    public CommonAsyncTask(Activity a) {
        caller = (OnAsyncRequestComplete) a;
        context = a;
    }

    public interface OnAsyncRequestComplete {
        public void asyncResponse(String m);
    }

    @Override
    protected String doInBackground(Handler... params) {
        client = new TCPClient(new TCPClient.OnMessageReceived() {
            @Override
            public void messageReceived(String message) {
                caller.asyncResponse(message);
            }
        });
        client.run();
        return null;
    }
}

收到消息后，我致电caller.asyncResponse(message)并在指定活动中运行。从主活动开始我开始一个新活动，我想在同一个新活动和主活动中使用相同的异步任务类同时触发caller.asyncResponse。如果有两个以上的活动，我想在所有活动中触发caller.asyncResponse。有可能这样做吗？

Answer 1

如果需要在所有活动中收到，那么你可能想要使用广播而不是回调。

BroadcastReceiver

的Android文档

由于您只想在自己的应用中进行广播，因此您还希望将其与LocalBroadcastManager

一起使用

This tutorial涵盖了您需要的所有内容。

样品像这样添加BroadcastReceiver到每个Activity

BroadcastReceiver rec = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            //all events will be received here
            //get message
            String message = intent.getStringExtra("message");
        }
    };
    LocalBroadcastManager.getInstance(this).registerReceiver(rec, new IntentFilter("event"));

发送广播。而不是caller.asyncResponse（消息）;

  Intent intent = new Intent("event");
  // add data
  intent.putExtra("message", message);
  LocalBroadcastManager.getInstance(context).sendBroadcast(intent);

Answer 2

对于某些活动，您可以使用处理程序。您需要按活动处理，然后，您向每个处理程序发送一条消息，每个活动都会收到它。

Answer 3

public class Async_Task extends AsyncTask<Object, Void, String>
{

    byte[] fileInByte;
    int req_no;
    boolean morefiles = false;
    String TAG = "Async_Task";

    private HttpHelper parsing;
    private MultipartEntity multipart;
    private File currentFileuploading = null;
    private Validations valid;
    private Context context;
    private Object obj;
    private SharedPreferences pref;
    private InternetSchedul internetStatus;
    private AudioSchedul recordingSchedul;
    int uploadtype = 0;

    public Async_Task(int Req_no, Context mContext)
    {
        this.req_no = Req_no;
        multipart = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
        context = mContext;
        valid = new Validations(context);
        internetStatus = new InternetSchedul();
        recordingSchedul = new AudioSchedul();
    }

    public Async_Task(int Req_no, Context mContext, Object mObj)
    {
        this(Req_no, mContext);
        obj = mObj;
    }

    @Override
    protected void onPreExecute()
    {

    }

    @Override
    protected String doInBackground(Object... urls)
    {

        String obj = "";
        parsing = new HttpHelper();
        pref = context.getSharedPreferences(Constant.PREF_APPDATA, Context.MODE_PRIVATE);

        if (req_no == Constant.REQ_AUTHENTICATION)
        {


        }
        else if (req_no == Constant.REQ_UPLOAD)
        {


        }
        else if (req_no == Constant.REQ_FORCE_STOP)
        {


        }

        return "";

    }

    public byte[] getFile(String type)
    {

        //return file in byte
    }

    @Override
    protected void onPostExecute(String result)
    {

                if (obj instanceof GCMIntentService)
                {
                    ((GCMIntentService) obj).getApiResponse(req_no);
                }
                else if (obj instanceof Internet_SD_CheckService)
                {

                }
                else if (obj instanceof Activity_Audio)
                {
                    ((Activity_Audio) obj).getApiResponse(req_no, result);
                }


    }
}

<强>调用

if(valid.isOnline())
            new Async_Task(Constant.REQ_AUTHENTICATION, Activity_Audio.this, Activity_Audio.this).execute();

如果您想要更多功能，请尝试以下链接。

http://www.technotalkative.com/android-volley-library-example/

Answer 4

您应为每次通话创建一个新的AsyncTask。

请参阅AsyncTask的文档，

线程规则

AsyncTask的目标是处理线程管理你和你不应该担心线程机制。
Android平台处理线程池来管理异步操作。 AsyncTasks就像消耗品。任务只能执行一次（如果一秒钟就会抛出异常尝试执行。）

来源：should-you-create-new-async-tasks-for-every-different-call-or-use-the-same-one

具有多个呼叫者的Android常见异步任务

4 个答案:

线程规则