Android 将异步任务结果传递给其他活动

我试图在启动屏幕期间从Parse.com检索数据

我在DoInBackground方法中进行查询，并添加在对象向量中检索到的所有对象（在另一个类中）

移动到主活动时，所有数据都会丢失

这是我的密码：

private class loadDataTask extends AsyncTask<Void, Void, Vector<PartyObj>>{


    @Override
    protected Vector<PartyObj> doInBackground(Void... params)  
    {  
        ParseQuery query = new ParseQuery("partyObj");
        query.whereExists("Name");
        query.findInBackground(new FindCallback() {

            @Override
            public void done(List<ParseObject> mNameList, ParseException e) {
                 if (e == null) {   
                       adapter.partyVector = new Vector<PartyObj>();               
                        for(int i=0; i<mNameList.size(); i++){
                            PartyObject party = new PartyObject();
                            party.setIndex(i);
                            party.setmName(mNameList.get(i).getString("Name").toString());
                            adapter.partyVector.add(party);

                 }
                         }else {
                        Log.d("mNameList", "Error: " + e.getMessage());                        
                    }

            }
        });
        return adpater.partyVector;  
    }  


    @Override
    protected void onPostExecute(Vector<PartyObj> result) {
        progressDialog.dismiss();
        setContentView(R.layout.activity_main_menu);            
    }

}

私有类loadDataTask扩展了AsyncTask{
@凌驾
受保护向量doInBackground（无效…参数）
{  
ParseQuery查询=新的ParseQuery（“partyObj”）；
查询：何处存在（“名称”）；
findInBackground（新的FindCallback（）{
@凌驾
公共作废完成（列表mNameList，parsee）{
如果（e==null）{
adapter.partyVector=新向量（）；
对于（int i=0；i看来您使用的AsyncTask是完全错误的。query.findInBackground（）是我所能知道的异步调用，因此您实际上是在将一个异步调用包装到另一个异步调用中。问题是，在query.findInBackground（）之后，代码执行会立即继续，从而结束doInBackground（）由于异步任务完成后立即移动到主活动，因此可能是query.findInBackground（）尚未完成（从而导致空/部分列表）

您真的确定需要将所有内容包装在异步调用中吗

ParseQuery query = new ParseQuery("partyObj");
query.whereExists("Name");

花点时间执行，或者大部分工作已经在async findInBackground（）调用中了？如果是这样，我会说跳过AsyncTask，在FindCallback的done（）方法中进行视图转换

最新消息：我已经读过了，上面清楚地写着：

通常首选使用回调方法，因为网络
操作不会阻止调用线程。但是，在某些情况下
可能更容易使用find、get或count调用，这些调用会阻止
调用线程。例如，如果应用程序已生成
后台任务执行工作时，该后台任务可以使用
阻止调用并避免回调的代码复杂性

其中明确指出：

从中检索满足此查询的ParseObject列表
服务器位于后台线程中。这比使用find（）更好，
除非您的代码已经在后台线程中运行

由于您已经在异步任务中包装了所有内容，您应该完全跳过异步任务，因为findInBackground（findInBackground）已经在后台线程中运行，或者切换到blocking方法

不带AsyncTask但使用async findInBackground（）的示例：

ParseQuery query=newparsequery（“partyObj”）；
查询：何处存在（“名称”）；
findInBackground（新的FindCallback（）{
@凌驾
公共作废完成（列表mNameList，parsee）{
如果（e==null）{
adapter.partyVector=新向量（）；
对于（inti=0；i我实现了类似的异步类来获取解析服务器数据

私有类Getneworders\u列表扩展了异步任务{
ArrayList neworders_hashmap；
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
neworders_RecycleView.getRecycledViewPool（）.clear（）；
}
@凌驾
受保护列表doInBackground（无效…参数）{
//创建数组
试一试{
ParseQuery=ParseQuery.getQuery（“订单”）；
ParseObject obj=ParseObject.createWithoutData（“ShopLocations”，idd）；
查询：whereEqualTo（“商店”，obj）；
查询.whereEqualTo（“订单状态”，0）；
setCachePolicy（ParseQuery.CachePolicy.IGNORE\u CACHE）；
query.orderByDescending（“updatedAt”）；
object11=query.find（）；
}捕获（解析异常）{
Log.d（“错误”，例如getMessage（））；
e、 printStackTrace（）；
}
返回对象11；
}
@凌驾
受保护的void onPostExecute（列表结果）{
neworders_hashmap=newarraylist（）；
如果（结果！=null）{
如果（result.size（）>0）{
chec（result.size（））；
m_Runnable.run（）；
}
}
}
}

使用full for some one
Hi，britzl，感谢您的响应。它确实在转到MainActivity之前完成了查询。我已经修复了代码中的一些错误，现在的问题是我不知道如何将onPostExecute方法结果中的对象传递到其他活动（我的listAdapter活动）。很抱歉，我看不出它如何在进入主要活动之前完成查询。我将更新我的答案以解释我对此的想法。是的……你是对的……：）我用10秒的线程在OnCreate上运行findInBackground，这一切都很好。还有两个问题：1.如何将向量对象传递到我的listAdapter？2.如何在findInBackground方法所需的准确时间长度内运行线程？谢谢…检查我更新的答案。你真的应该选择我提供的两个解决方案中的一个。Th您的代码将按预期运行，并暂停执行查询所需的时间
ParseQuery query = new ParseQuery("partyObj");
query.whereExists("Name");
query.findInBackground(new FindCallback() {

    @Override
    public void done(List<ParseObject> mNameList, ParseException e) {
        if (e == null) {   
            adapter.partyVector = new Vector<PartyObj>();               
            for(int i=0; i<mNameList.size(); i++){
                PartyObject party = new PartyObject();
                party.setIndex(i);
                party.setmName(mNameList.get(i).getString("Name").toString());
                adapter.partyVector.add(party);
            }

            progressDialog.dismiss();
            setContentView(R.layout.activity_main_menu);                    
        }
        else {
            Log.d("mNameList", "Error: " + e.getMessage());                        
        }

    }
});

private class loadDataTask extends AsyncTask<Void, Void, Vector<PartyObj>>{

    @Override
    protected Vector<PartyObj> doInBackground(Void... params)  
    {  
        ParseQuery query = new ParseQuery("partyObj");
        query.whereExists("Name");
        Vector<PartyObject> v = new Vector<PartyObject();
        try {
            List<ParseObject> queryResult = query.find();
            for(ParseObject po : queryResult) {
                PartyObject party = new PartyObject();
                party.setIndex(partyVector.size());
                party.setmName(po.getString("Name").toString());
                v.add(party);
            }
        }
        catch(ParseException e) {
            Log.d("mNameList", "Error: " + e.getMessage());
        }
        return v;
    }

    @Override
    protected void onPostExecute(Vector<PartyObj> result) {
        adapter.partyVector.addAll(result);
        progressDialog.dismiss();
        setContentView(R.layout.activity_main_menu);            
    }
}

 private class Getneworders_list extends AsyncTask<Void, Void, List<ParseObject>> {

    ArrayList<HashMap<String, String>>  neworders_hashmap;

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        neworders_recyclerView.getRecycledViewPool().clear();
    }

    @Override
    protected List<ParseObject> doInBackground(Void... params) {

        // Create the array
        try {

            ParseQuery<ParseObject> query = ParseQuery.getQuery("Orders");
            ParseObject obj = ParseObject.createWithoutData("ShopLocations", idd);
            query.whereEqualTo("shop", obj);
            query.whereEqualTo("orderStatus",0);
            query.setCachePolicy(ParseQuery.CachePolicy.IGNORE_CACHE);
            query.orderByDescending("updatedAt");
            object11 = query.find();

        } catch (ParseException e) {
            Log.d("Error", e.getMessage());
            e.printStackTrace();
        }

        return object11;
    }

    @Override
    protected void onPostExecute(List<ParseObject> result) {

        neworders_hashmap = new ArrayList<HashMap<String, String>>();

        if(result != null) {

            if (result.size() > 0) {
                chec(result.size());
                m_Runnable.run();
            }
        }

    }
}