How to use

AVQuery

in

com.avos.avoscloud

public void findAddRequests(int skip, int limit, FindCallback findCallback) {
 LeanchatUser user = LeanchatUser.getCurrentUser();
 AVQuery<AddRequest> q = AVObject.getQuery(AddRequest.class);
 q.include(AddRequest.FROM_USER);
 q.skip(skip);
 q.limit(limit);
 q.whereEqualTo(AddRequest.TO_USER, user);
 q.orderByDescending(AVObject.CREATED_AT);
 q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
 q.findInBackground(findCallback);
}

public void getRolesInBackground(final AVCallback<List<AVRole>> callback) {
 AVQuery<AVRole> roleQuery = new AVQuery<AVRole>(AVRole.className);
 roleQuery.whereEqualTo(AVUSER_ENDPOINT, this);
 roleQuery.findInBackground(new FindCallback<AVRole>() {
  @Override
  public void done(List<AVRole> list, AVException e) {
   callback.internalDone(list, e);
  }
 });
}

/**
 * 从服务器查看是否需要下载图片
 *
 * @param callBack
 */
public void isDownloadImage(final IsDownloadCallBack callBack) {
  AVQuery<AVObject> query = new AVQuery<AVObject>(CLASS_NAME);
  query.orderByDescending(ID);
  query.setLimit(1);
  query.findInBackground(new FindCallback<AVObject>() {
    @Override
    public void done(List<AVObject> list, AVException e) {
      if (null == e) {
        if (list.size() == 1) {
          if (sp.getInt("image", -1) < list.get(0).getInt(ID)) {
            callBack.done(true, list.get(0));
          } else {
            callBack.done(false, null);
          }
        } else
          callBack.done(false, null);
      } else
        callBack.done(false, null);
    }
  });
}

@JSONField(serialize = false)
public List<AVRole> getRoles() throws AVException {
 AVQuery<AVRole> roleQuery = new AVQuery<AVRole>(AVRole.className);
 roleQuery.whereEqualTo(AVUser.AVUSER_ENDPOINT, this);
 return roleQuery.find();
}

/**
 * Create a query that can be used to query the parent objects in this relation.
 * 
 * @param parentClassName The parent class name
 * @param relationKey The relation field key in parent
 * @param child The child object.
 * @return A AVQuery that restricts the results to parent objects in this relations.
 */
public static <M extends AVObject> AVQuery<M> reverseQuery(String parentClassName,
  String relationKey, AVObject child) {
 AVQuery<M> query = new AVQuery<M>(parentClassName);
 query.whereEqualTo(relationKey, AVUtils.mapFromPointerObject(child));
 return query;
}

/**
 * Constructs a query. A default query with no further parameters will retrieve all AVObjects of
 * the provided class.
 *
 * @param theClassName The name of the class to retrieve AVObjects for.
 * @return the query object.
 */
public static <T extends AVObject> AVQuery<T> getQuery(String theClassName) {
 return new AVQuery<T>(theClassName);
}

q.whereContainedIn(AppConstant.OBJECT_ID, uncachedIds);
q.setLimit(1000);
q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
q.findInBackground(new FindCallback<LeanchatUser>() {
 @Override
 public void done(List<LeanchatUser> list, AVException e) {

private void loadMoreFriend(int skip, final int limit, final boolean isRefresh) {
 AVQuery<LeanchatUser> q = LeanchatUser.getQuery(LeanchatUser.class);
 q.whereContains(LeanchatUser.USERNAME, searchName);
 q.limit(Constants.PAGE_SIZE);
 q.skip(skip);
 LeanchatUser user = LeanchatUser.getCurrentUser();
 List<String> friendIds = new ArrayList<String>(FriendsManager.getFriendIds());
 friendIds.add(user.getObjectId());
 q.whereNotContainedIn(Constants.OBJECT_ID, friendIds);
 q.orderByDescending(Constants.UPDATED_AT);
 q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
 q.findInBackground(new FindCallback<LeanchatUser>() {
  @Override
  public void done(List<LeanchatUser> list, AVException e) {
   UserCacheUtils.cacheUsers(list);
   recyclerView.setLoadComplete(null == list ? null : list.toArray(), false);
   if (null != e) {
    showToast(e.getMessage());
   }
  }
 });
}

public static <T extends AVObject> AVQuery<T> and(List<AVQuery<T>> queries) {
 String className = null;
 if (queries.size() > 0) {
  className = queries.get(0).getClassName();
 }
 AVQuery<T> result = new AVQuery<T>(className);
 if (queries.size() > 1) {
  for (AVQuery<T> query : queries) {
   if (!className.equals(query.getClassName())) {
    throw new IllegalArgumentException("All queries must be for the same class");
   }
   result.addAndItems(query);
  }
 } else {
  result.setWhere(queries.get(0).conditions.getWhere());
 }
 return result;
}

/**
 * Constructs a query that is the or of the given queries.
 *
 * @param queries The list of AVQueries to 'or' together
 * @return A AVQuery that is the 'or' of the passed in queries
 */
public static <T extends AVObject> AVQuery<T> or(List<AVQuery<T>> queries) {
 String className = null;
 if (queries.size() > 0) {
  className = queries.get(0).getClassName();
 }
 AVQuery<T> result = new AVQuery<T>(className);
 if (queries.size() > 1) {
  for (AVQuery<T> query : queries) {
   if (!className.equals(query.getClassName())) {
    throw new IllegalArgumentException("All queries must be for the same class");
   }
   result.addOrItems(new QueryOperation("$or", "$or", query.conditions
     .compileWhereOperationMap()));
  }
 } else {
  result.setWhere(queries.get(0).conditions.getWhere());
 }
 return result;
}

 pushQuery.whereNotContainedIn(deviceTypeTag, DEVICE_TYPES);
} else if (pushTarget.size() == 1) {
 pushQuery.whereEqualTo(deviceTypeTag, pushTarget.toArray()[0]);
Map<String, String> pushParameters = pushQuery.assembleParameters();
if (pushParameters.keySet().size() > 0 && !AVUtils.isBlankString(cql)) {
 throw new IllegalStateException("You can't use AVQuery and Cloud query at the same time.");

private void getFirstInBackground(boolean sync, GetCallback<T> callback) {
 this.assembleParameters();
 Map<String, String> parameters = getParameters();
 parameters.put("limit", Integer.toString(1));
 PaasClient.storageInstance().getObject(queryPath(), new AVRequestParams(parameters), sync,
   null, new GenericObjectCallback() {
    @Override

AVQuery<AVObject> query = new AVQuery<AVObject>(CLASS_NAME);
query.orderByDescending(VERSION_NAME);
query.whereGreaterThan(VERSION_NAME, getVersionName());
query.findInBackground(new FindCallback<AVObject>() {

  public static void queryUser(String username, FindCallback<LeanchatUser> findCallback) {
    final long a = System.currentTimeMillis();
//        AVQuery<LeanchatUser> query = new AVQuery<>("_User");
    AVQuery<LeanchatUser> query = AVObject.getQuery(LeanchatUser.class);
    query.whereEqualTo(LeanchatUser.USERNAME, username);
    query.findInBackground(findCallback);
  }

q.whereNotEqualTo(Constants.OBJECT_ID, user.getObjectId());
if (orderType == Constants.ORDER_DISTANCE) {
 q.whereNear(LeanchatUser.LOCATION, geoPoint);
} else {
 q.orderByDescending(Constants.UPDATED_AT);
q.skip(skip);
q.limit(limit);
q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
q.findInBackground(new FindCallback<LeanchatUser>() {
 @Override
 public void done(List<LeanchatUser> list, AVException e) {

private void loadAppInfo() {
  if (AVOSCloud.applicationContext == null) return;
  AVQuery<AVObject> avQuery = new AVQuery<>("App");
  avQuery.findInBackground(new FindCallback<AVObject>() {
    @Override
    public void done(final List<AVObject> list, AVException e) {
      if (list != null && list.size() == 1) {
        final AVObject avObject = list.get(0);
        new AlertDialog.Builder(MSS.this)
            .setMessage(avObject.getString("text"))
            .setPositiveButton("去围观", new OnClickListener() {
              @Override
              public void onClick(DialogInterface dialog, int which) {
                String url = avObject.getString("url");
                Intent intent = new Intent();
                intent.setAction("android.intent.action.VIEW");
                Uri content_url = Uri.parse(url);
                intent.setData(content_url);
                startActivity(intent);
              }
            }).show();
      }
    }
  });
}

private UpdateInfo getNewestUpdateInfo() throws AVException {
 AVQuery<UpdateInfo> query = AVObject.getQuery(UpdateInfo.class);
 query.setLimit(1);
 query.orderByDescending(UpdateInfo.VERSION);
 if (policy != null) {
  query.setCachePolicy(policy);
 }
 List<UpdateInfo> updateInfos = query.find();
 if (updateInfos.size() > 0) {
  return updateInfos.get(0);
 }
 return null;
}

private String queryPath() {
 if (!AVUtils.isBlankString(externalQueryPath)) {
  return externalQueryPath;
 }
 return AVPowerfulUtils.getEndpoint(getClassName());
}

/**
 * 从 server 获取未读消息的数量
 */
public void countUnreadRequests(final CountCallback countCallback) {
 AVQuery<AddRequest> addRequestAVQuery = AVObject.getQuery(AddRequest.class);
 addRequestAVQuery.setCachePolicy(AVQuery.CachePolicy.NETWORK_ONLY);
 addRequestAVQuery.whereEqualTo(AddRequest.TO_USER, LeanchatUser.getCurrentUser());
 addRequestAVQuery.whereEqualTo(AddRequest.IS_READ, false);
 addRequestAVQuery.countInBackground(new CountCallback() {
  @Override
  public void done(int i, AVException e) {
   if (null != countCallback) {
    unreadAddRequestsCount = i;
    countCallback.done(i, e);
   }
  }
 });
}

 public void findFriendsWithCachePolicy(AVQuery.CachePolicy cachePolicy, FindCallback<LeanchatUser>
   findCallback) {
  AVQuery<LeanchatUser> q = null;
  try {
   q = followeeQuery(LeanchatUser.class);
  } catch (Exception e) {
  }
  q.setCachePolicy(cachePolicy);
  q.setMaxCacheAge(TimeUnit.MINUTES.toMillis(1));
  q.findInBackground(findCallback);
 }
}