Android ParseQueryAdapter未获取项目

我有一个ListView，我使用Parse.com获取数据，我使用ParseQueryAdapter获取ListView。但是我看不到适配器正在获取数据

这是我的密码

public class MainActivity extends ActionBarActivity {

    private ArrayList<Date> dateHeaders;
    private HashMap<Date,ArrayList<Sessions>> dateContent;

    private ParseQueryAdapter<Sessions> sessionsQueryAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d("test", "query");
        Parse.enableLocalDatastore(this);
        Parse.initialize(this, "xxx", "xxx");
        ParseObject.registerSubclass(Sessions.class);

        //sessionHeaderFetch();
        ParseQueryAdapter.QueryFactory<Sessions>  factory = new ParseQueryAdapter.QueryFactory<Sessions>(){
            @Override
            public ParseQuery<Sessions> create() {
                ParseQuery<Sessions> query = Sessions.getQuery();
                query.include("sessionId");
                query.include("Location");
                Log.d("test", "query");
                return query;
            }
        };

        sessionsQueryAdapter = new ParseQueryAdapter<Sessions>(this, factory){
            public View getItemView(Sessions sessions, View view, ViewGroup parent){
                if(view == null){
                    view = View.inflate(getContext(), R.layout.session_list_item, null);
                }
                Log.d("test", "adapter");
                TextView teamName = (TextView) view.findViewById(R.id.teamName);
                TextView location = (TextView) view.findViewById(R.id.location);
                TextView time = (TextView) view.findViewById(R.id.netsTime);
                TextView slots = (TextView) view.findViewById(R.id.slots);
                TextView bookedSlots = (TextView) view.findViewById(R.id.players);
                TextView openSlots = (TextView) view.findViewById(R.id.openSlots);
                teamName.setText(sessions.getSessionId());
                location.setText(sessions.getLocation());
                time.setText((CharSequence) sessions.getNetsDate());
                slots.setText(sessions.getSlots());
                bookedSlots.setText(sessions.getOpenSlots());
                openSlots.setText(sessions.getOpenSlots());
                return view;
            }
        };

        sessionsQueryAdapter.setAutoload(false);
        sessionsQueryAdapter.setPaginationEnabled(false);

        ListView listView = (ListView) findViewById(R.id.expandableListView);
        sessionsQueryAdapter.setTextKey("sessionId");
        listView.setAdapter(sessionsQueryAdapter);

    }
}

公共类MainActivity扩展了ActionBarActivity{
私有ArrayList日期头；
私有HashMap数据内容；
专用ParseQueryAdapter会话QueryAdapter；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
Log.d（“测试”、“查询”）；
enableLocalDatastore（this）；
初始化（这是“xxx”，“xxx”）；
ParseObject.registerSubclass（Sessions.class）；
//sessionHeaderFetch（）；
ParseQueryAdapter.QueryFactory=新建ParseQueryAdapter.QueryFactory（）{
@凌驾
公共ParseQuery创建（）{
ParseQuery=Sessions.getQuery（）；
查询。包括（“sessionId”）；
查询。包括（“位置”）；
Log.d（“测试”、“查询”）；
返回查询；
}
};
sessionsQueryAdapter=新的ParseQueryAdapter（此，工厂）{
公共视图getItemView（会话、视图视图、视图组父级）{
如果（视图==null）{
视图=视图.充气（getContext（），R.layout.session\u list\u项，null）；
}
Log.d（“测试”、“适配器”）；
TextView teamName=（TextView）view.findViewById（R.id.teamName）；
TextView位置=（TextView）view.findViewById（R.id.location）；
TextView时间=（TextView）view.findViewById（R.id.netsTime）；
TextView插槽=（TextView）view.findViewById（R.id.slots）；
TextView bookedSlots=（TextView）view.findViewById（R.id.players）；
TextView openSlots=（TextView）view.findviewbyd（R.id.openSlots）；
teamName.setText（sessions.getSessionId（））；
setText（sessions.getLocation（））；
time.setText（（CharSequence）sessions.getNetsDate（））；
slots.setText（sessions.getSlots（））；
bookedSlots.setText（sessions.getOpenSlots（））；
setText（sessions.getOpenSlots（））；
返回视图；
}
};
sessionsQueryAdapter.setAutoload（false）；
SessionQueryAdapter.setPaginationEnabled（false）；
ListView ListView=（ListView）findViewById（R.id.expandableListView）；
sessionsQueryAdapter.setTextKey（“sessionId”）；
setAdapter（sessionsQueryAdapter）；
}
}

与其他getter和setter一样，我在解析模型类中也有以下方法

public static ParseQuery<Sessions> getQuery() {
        Log.d("test", "inside query");
        return ParseQuery.getQuery(Sessions.class);
    }

publicstaticparsequerygetquery（）{
Log.d（“测试”、“内部查询”）；
返回ParseQuery.getQuery（Sessions.class）；
}

解析类

@ParseClassName("Sessions")
public class Sessions extends ParseObject {
    public Sessions(){

    }

    public String sessionId;
    public String location;
    public String netNo;
    public String userId;
    public int slots;
    public int openSlots;
    public Date netsDate;

    public String getSessionId() {
        return getString("SessionId");
    }

    public void setSessionId(String sessionId) {
        put("SessionId", sessionId);
    }

    public String getLocation() {
        return getString("Location");
    }

    public void setLocation(String location) {
        put("Location", location);
    }

    public String getNetNo() {
        return getString("NetNo");
    }

    public void setNetNo(String netNo) {
        put("NetNo", netNo);
    }

    public String getUserId() {
        return getString("UserId");
    }

    public void setUserId(String userId) {
        put("UserId", userId);
    }

    public int getSlots() {
        return getInt("Slots");
    }

    public void setSlots(int slots) {
        put("Slots", slots);
    }

    public int getOpenSlots() {
        return getInt("OpenSlots");
    }

    public void setOpenSlots(int openSlots) {
        put("OpenSlots", openSlots);
    }

    public Date getNetsDate() {
        return getDate("NetsDate");
    }

    public void setNetsDate(Date netsDate) {
        put("NetsDate", netsDate);
    }

    public static ParseQuery<Sessions> getQuery() {
        Log.d("test", "inside query");
        return ParseQuery.getQuery(Sessions.class);
    }
}

@ParseClassName（“会话”）
公共类会话扩展了ParseObject{
公开会议（）{
}
公共字符串sessionId；
公共字符串位置；
公共字符串netNo；
公共字符串用户标识；
公共int插槽；
公共int开放式插槽；
公开日期；
公共字符串getSessionId（）{
返回getString（“SessionId”）；
}
public void setSessionId（字符串sessionId）{
put（“SessionId”，SessionId）；
}
公共字符串getLocation（）{
返回getString（“位置”）；
}
公共void集合位置（字符串位置）{
放置（“位置”，位置）；
}
公共字符串getNetNo（）{
返回getString（“NetNo”）；
}
公共void setNetNo（字符串netNo）{
put（“NetNo”，NetNo）；
}
公共字符串getUserId（）{
返回getString（“UserId”）；
}
public void setUserId（字符串userId）{
put（“UserId”，UserId）；
}
公共int getSlots（）{
返回getInt（“插槽”）；
}
公共无效设置槽（int槽）{
放置（“插槽”，插槽）；
}
public int getOpenSlots（）{
返回getInt（“OpenSlots”）；
}
public void setOpenSlots（int openSlots）{
put（“OpenSlots”，OpenSlots）；
}
公共日期getNetsDate（）{
返回getDate（“NetsDate”）；
}
公共无效设置netsDate（日期netsDate）{
put（“NetsDate”，NetsDate）；
}
公共静态ParseQuery getQuery（）{
Log.d（“测试”、“内部查询”）；
返回ParseQuery.getQuery（Sessions.class）；
}
}

在聊天中与我共享代码后，我相信这是最适合您的解决方案： 将您的parseIO更改为：

public class ParseIO {  

public void sessionFetch(Date headers, final ParseIOListener<Sessions> listener){ 
     ParseQuery<Sessions> query = ParseQuery.getQuery(Sessions.class); 
     query.whereEqualTo("NetsDate",headers); 
     final ArrayList<Sessions> sessionsData = new ArrayList<Sessions>(); 
     query.findInBackground(new FindCallback<Sessions>() { 
       @Override 
       public void done(List<Sessions> sessionsObjects, com.parse.ParseException e) { 
            if (e == null) { 
               for (Sessions session : sessionsObjects) { 
                  sessionsData.add(session); 
               } 
               listener.onDataRetrieved(sessionsData); 
            } else { 
                listener.onDataRetrieveFail(e); 
            } 
         } 
     });  
 } 

 public void sessionHeaderFetch(final ParseIOListener<Date> listener){ 

      Log.d("test", "session fetch entry"); 
      ParseQuery<Sessions> query = ParseQuery.getQuery(Sessions.class); 
      final ArrayList<Date> sessionHeaders = new ArrayList<Date>(); 
      query.findInBackground(new FindCallback<Sessions>() { 
           @Override 
           public void done(List<Sessions> sessionsObjects, com.parse.ParseException e) { 
                if (e == null) { 
                    Log.d("test", "Retrieved -- hello" + sessionsObjects.size() + " sessions"); 
                    for (Sessions session : sessionsObjects) { 
                        sessionHeaders.add(session.getNetsDate()); 
                    } 
                    Log.d("test", "Parse fetched headers" + sessionHeaders.size()); 
                    listener.onDataRetrieved(sessionHeaders); 
                } else { 
                   Log.d("test", "Error: " + e.getMessage()); 
                   listener.onDataRetrieveFail(e); 
                } 
            } 
       }); 

  } 

  public interface ParseIOListener<T>{ 
       void onDataRetrieved(ArrayList<T> listOfData); 
       void onDataRetrieveFail(ParseException e); 
  } 
}

公共类解析{
public void sessionFetch（日期头，最终ParseIOListener侦听器）{
ParseQuery=ParseQuery.getQuery（Sessions.class）；
查询。whereEqualTo（“netdate”，标题）；
最终ArrayList会话数据=新ArrayList（）；
query.findInBackground（新的FindCallback（）{
@凌驾
public void done（列出sessionobjects，com.parse.ParseException e）{
如果（e==null）{
对于（会话：会话对象）{
sessionsData.add（会话）；
} 
已检索listener.ondata（sessionsData）；
}否则{
listener.onDataRetrieveFail（e）；
} 
} 
});  
} 
public void sessionHeaderFetch（最终ParseIOListener侦听器）{
Log.d（“测试”、“会话获取条目”）；
ParseQuery=ParseQuery.getQuery（Sessions.class）；
final ArrayList sessionHeaders=new ArrayList（）；
query.findInBackground（新的FindCallback（）{
@凌驾
public void done（列出sessionobjects，com.parse.ParseException e）{
如果（e==null）{
d（“test”，“Retrieved--hello”+sessionsObjects.size（）+“sessions”）；
对于（会话：会话对象）{
会话he
 sessionHeaderFetch(new ParseIOListener<Date>() { 
     @Override 
     public void onDataRetrieved(ArrayList<Date> listOfData) { 
         //here you have your listOfData
     } 

     @Override 
     public void onDataRetrieveFail(ParseException e) { 
         //error. Log it out and handle it here
     } 
 });