com.google.android.gms.drive.query.Filters Java Examples

@DebugLog
public void readFileContent(final String file_name, final List<Metadata> remainings) {
    Query query = new Query.Builder()
            .addFilter(Filters.eq(SearchableField.TITLE, file_name))
            .build();

    app_folder_for_user.queryChildren(_parent.getClient(), query)
            .setResultCallback(new ResultCallback<DriveApi.MetadataBufferResult>() {
                @Override
                public void onResult(DriveApi.MetadataBufferResult metadataBufferResult) {
                    MetadataBuffer buffer = metadataBufferResult.getMetadataBuffer();
                    int count = buffer.getCount();
                    if (count > 0) {
                        readFileFromDrive(buffer, buffer.get(0).getDriveId());
                    } else {
                        _parent.onFileRead(null);
                    }

                    readFileContent(remainings);
                }
            });
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFiles() {
    Query query =
            new Query.Builder()
                    .addFilter(Filters.or(Filters.eq(SearchableField.MIME_TYPE, "text/html"),
                            Filters.eq(SearchableField.MIME_TYPE, "text/plain")))
                    .build();
    getDriveResourceClient()
            .query(query)
            .addOnSuccessListener(this,
                    metadataBuffer -> mResultsAdapter.append(metadataBuffer))
            .addOnFailureListener(this, e -> {
                Log.e(TAG, "Error retrieving files", e);
                showMessage(getString(R.string.query_failed));
                finish();
            });
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFiles() {
    Query query =
            new Query.Builder()
                    .addFilter(Filters.not(Filters.eq(SearchableField.MIME_TYPE, "text/plain")))
                    .build();
    getDriveResourceClient()
            .query(query)
            .addOnSuccessListener(this,
                    metadataBuffer -> mResultsAdapter.append(metadataBuffer))
            .addOnFailureListener(this, e -> {
                Log.e(TAG, "Error retrieving files", e);
                showMessage(getString(R.string.query_failed));
                finish();
            });
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFilesInFolder(DriveFolder folder) {
    Query query = new Query.Builder()
                          .addFilter(Filters.eq(SearchableField.MIME_TYPE, "text/plain"))
                          .build();
    // [START drive_android_query_children]
    Task<MetadataBuffer> queryTask = getDriveResourceClient().queryChildren(folder, query);
    // END drive_android_query_children]
    queryTask
            .addOnSuccessListener(this,
                    metadataBuffer -> mResultsAdapter.append(metadataBuffer))
            .addOnFailureListener(this, e -> {
                Log.e(TAG, "Error retrieving files", e);
                showMessage(getString(R.string.query_failed));
                finish();
            });
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFiles() {
    // [START drive_android_query_conditions]
    Query query =
            new Query.Builder()
                    .addFilter(Filters.and(Filters.eq(SearchableField.MIME_TYPE, "text/plain"),
                            Filters.eq(SearchableField.STARRED, true)))
                    .build();
    // [END drive_android_query_conditions]
    getDriveResourceClient()
            .query(query)
            .addOnSuccessListener(this,
                    metadataBuffer -> mResultsAdapter.append(metadataBuffer))
            .addOnFailureListener(this, e -> {
                Log.e(TAG, "Error retrieving files", e);
                showMessage(getString(R.string.query_failed));
                finish();
            });
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFiles() {
    // [START drive_android_query_title]
    Query query = new Query.Builder()
                          .addFilter(Filters.eq(SearchableField.TITLE, "HelloWorld.txt"))
                          .build();
    // [END drive_android_query_title]
    Task<MetadataBuffer> queryTask =
            getDriveResourceClient()
                    .query(query)
                    .addOnSuccessListener(this,
                            metadataBuffer -> mResultsAdapter.append(metadataBuffer))
                    .addOnFailureListener(this, e -> {
                        Log.e(TAG, "Error retrieving files", e);
                        showMessage(getString(R.string.query_failed));
                        finish();
                    });
}
 

/**
 * Retrieves the list from Drive if it exists. If not, create a new list.
 */
private Task<Void> initializeGroceryList() {
    Log.d(TAG, "Locating grocery list file.");
    Query query = new Query.Builder()
                          .addFilter(Filters.eq(SearchableField.TITLE,
                                  getResources().getString(R.string.groceryListFileName)))
                          .build();
    return getDriveResourceClient()
            .query(query)
            .continueWithTask(task -> {
                MetadataBuffer metadataBuffer = task.getResult();
                try {
                    if (metadataBuffer.getCount() == 0) {
                        return createNewFile();
                    } else {
                        DriveId id = metadataBuffer.get(0).getDriveId();
                        return Tasks.forResult(id.asDriveFile());
                    }
                } finally {
                    metadataBuffer.release();
                }
            })
            .continueWithTask(task -> loadContents(task.getResult()));
}
 

@Subscribe(threadMode = ThreadMode.BACKGROUND)
public void listFiles(DoDriveListFiles event) {
    try {
        String targetFolder = getDriveFolderName();
        ConnectionResult connectionResult = connect();
        if (connectionResult.isSuccess()) {
            DriveFolder folder = getDriveFolder(targetFolder);
            Query query = new Query.Builder()
                    .addFilter(Filters.and(
                            Filters.eq(SearchableField.MIME_TYPE, Export.BACKUP_MIME_TYPE),
                            Filters.eq(SearchableField.TRASHED, false)
                    ))
                    .build();
            DriveApi.MetadataBufferResult metadataBufferResult = folder.queryChildren(googleApiClient, query).await();
            if (metadataBufferResult.getStatus().isSuccess()) {
                List<DriveFileInfo> driveFiles = fetchFiles(metadataBufferResult);
                handleSuccess(driveFiles);
            } else {
                handleFailure(metadataBufferResult.getStatus());
            }
        } else {
            handleConnectionResult(connectionResult);
        }
    } catch (Exception e) {
        handleError(e);
    }
}
 

private DriveFolder getOrCreateDriveFolder(String targetFolder) throws IOException {
    Query query = new Query.Builder().addFilter(Filters.and(
            Filters.eq(SearchableField.TRASHED, false),
            Filters.eq(SearchableField.TITLE, targetFolder),
            Filters.eq(SearchableField.MIME_TYPE, "application/vnd.google-apps.folder")
    )).build();
    DriveApi.MetadataBufferResult result = Drive.DriveApi.query(googleApiClient, query).await();
    if (result.getStatus().isSuccess()) {
        DriveId driveId = fetchDriveId(result);
        if (driveId != null) {
            return Drive.DriveApi.getFolder(googleApiClient, driveId);
        }
    }
    return createDriveFolder(targetFolder);
}
 

private Task<DriveId> pickFile() {
    OpenFileActivityOptions openOptions =
            new OpenFileActivityOptions.Builder()
                    .setSelectionFilter(Filters.eq(SearchableField.MIME_TYPE, "application/db"))
                    .setActivityTitle("Select DB File")
                    .build();
    return pickItem(openOptions);
}
 

/**
 * Asynchronously queries Drive within the passed params to find a DriveFile
 * @param driveClient the {@link GoogleApiClient} to use for this Drive request
 * @param folder the {@link DriveFolder} to query within
 * @param filename the filename to query for
 */
public void findFile(GoogleApiClient driveClient, DriveFolder folder, String filename) {
    // Make filename filter
    Filter filenameFilter = Filters.eq(SearchableField.TITLE, filename);

    // Build query with filter
    Query query = new Query.Builder()
            .addFilter(filenameFilter)
            .build();

    // Execute query on folder
    folder.queryChildren(driveClient, query).setResultCallback(this);
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFiles() {
    CustomPropertyKey customPropertyKey =
            new CustomPropertyKey("approved", CustomPropertyKey.PUBLIC);
    Query query = new Query.Builder().addFilter(Filters.eq(customPropertyKey, "yes")).build();
    getDriveResourceClient()
            .query(query)
            .addOnSuccessListener(this,
                    metadataBuffer -> mResultsAdapter.append(metadataBuffer))
            .addOnFailureListener(this, e -> {
                Log.e(TAG, "Error retrieving files", e);
                showMessage(getString(R.string.query_failed));
                finish();
            });
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFiles() {
    Query query = new Query.Builder()
                          .addFilter(Filters.eq(SearchableField.MIME_TYPE, "text/plain"))
                          .build();
    // [START drive_android_query_files]
    Task<MetadataBuffer> queryTask = getDriveResourceClient().query(query);
    // [END drive_android_query_files]
    // [START drive_android_query_results]
    queryTask
            .addOnSuccessListener(this,
                    metadataBuffer -> {
                        // Handle results...
                        // [START_EXCLUDE]
                        mResultsAdapter.append(metadataBuffer);
                        // [END_EXCLUDE]
                    })
            .addOnFailureListener(this, e -> {
                // Handle failure...
                // [START_EXCLUDE]
                Log.e(TAG, "Error retrieving files", e);
                showMessage(getString(R.string.query_failed));
                finish();
                // [END_EXCLUDE]
            });
    // [END drive_android_query_results]
}
 

/**
 * Retrieves results for the next page. For the first run,
 * it retrieves results for the first page.
 */
private void listFiles() {
    Query query = new Query.Builder().addFilter(Filters.sharedWithMe()).build();
    getDriveResourceClient()
            .query(query)
            .addOnSuccessListener(metadatabuffer -> mResultsAdapter.append(metadatabuffer))
            .addOnFailureListener(e -> {
                Log.e(TAG, "Error retrieving files", e);
                showMessage(getString(R.string.query_failed));
                finish();
            });
}
 

/**
 * Prompts the user to select a text file using OpenFileActivity.
 *
 * @return Task that resolves with the selected item's ID.
 */
protected Task<DriveId> pickTextFile() {
    OpenFileActivityOptions openOptions =
            new OpenFileActivityOptions.Builder()
                    .setSelectionFilter(Filters.eq(SearchableField.MIME_TYPE, "text/plain"))
                    .setActivityTitle(getString(R.string.select_file))
                    .build();
    return pickItem(openOptions);
}
 

/**
 * Prompts the user to select a folder using OpenFileActivity.
 *
 * @return Task that resolves with the selected item's ID.
 */
protected Task<DriveId> pickFolder() {
    OpenFileActivityOptions openOptions =
            new OpenFileActivityOptions.Builder()
                    .setSelectionFilter(
                            Filters.eq(SearchableField.MIME_TYPE, DriveFolder.MIME_TYPE))
                    .setActivityTitle(getString(R.string.select_folder))
                    .build();
    return pickItem(openOptions);
}