Manage objects

List all objects in a bucket

 ListObjectsRequest listObjects = new ListObjectsRequest("<bucketName>");
// Set a prefix
listObjects.setPrefix("file");
// Set a success callback and a failure callback, and send an asynchronous list request
OSSAsyncTask task = oss.asyncListObjects(listObjects, new OSSCompletedCallback<ListObjectsRequest, ListObjectsResult>() {
    @Override
    public void onSuccess(ListObjectsRequest request, ListObjectsResult result) {
        Log.d("AyncListObjects", "Success!");
        for (int i = 0; i < result.getObjectSummaries().size(); i++) {
            Log.d("AyncListObjects", "object: " + result.getObjectSummaries().get(i).getKey() + " "
                    + result.getObjectSummaries().get(i).getETag() + " "
                    + result.getObjectSummaries().get(i).getLastModified());
        }
    }
    @Override
    public void onFailure(ListObjectsRequest request, ClientException clientExcepion, ServiceException serviceException) {
        // Request exception
        if (clientExcepion != null) {
            // Local exception, such as a network exception
            clientExcepion.printStackTrace();
        }
        if (serviceException != null) {
            // Service exception
            Log.e("ErrorCode", serviceException.getErrorCode());
            Log.e("RequestId", serviceException.getRequestId());
            Log.e("HostId", serviceException.getHostId());
            Log.e("RawMessage", serviceException.getRawMessage());
        }
    }
});
task.waitUntilFinished();

The preceding code enlists all objects whose name contains the “file” prefix in a bucket. Settable parameter names and their functions are as follows:

Note: When you make a query using the prefix, the returned key still contains a prefix. |

Check object availability

OSS Android SDK provides an easy-to-use synchronous interface to check whether a specified object exists on OSS:

try {
    if (oss.doesObjectExist("<bucketName>", "<objectKey>")) {
        Log.d("doesObjectExist", "object exist.");
    } else {
        Log.d("doesObjectExist", "object does not exist.");
    }
} catch (ClientException e) {
    // Local exception, such as a network exception
    e.printStackTrace();
} catch (ServiceException e) {
    // Service exception
    Log.e("ErrorCode", e.getErrorCode());
    Log.e("RequestId", e.getRequestId());
    Log.e("HostId", e.getHostId());
    Log.e("RawMessage", e.getRawMessage());
}

Copy an object

// Create a COPY request
CopyObjectRequest copyObjectRequest = new CopyObjectRequest("<srcBucketName>", "<srcObjectKey>",
        "<destBucketName>", "<destObjectKey>");
// Configure the metadata of the object to be copied (optional)
// ObjectMetadata objectMetadata = new ObjectMetadata();
// objectMetadata.setContentType("application/octet-stream");
// copyObjectRequest.setNewObjectMetadata(objectMetadata);
// Asynchronous COPY
OSSAsyncTask copyTask = oss.asyncCopyObject(copyObjectRequest, new OSSCompletedCallback<CopyObjectRequest, CopyObjectResult>() {
    @Override
    public void onSuccess(CopyObjectRequest request, CopyObjectResult result) {
            Log.d("copyObject", "copy success!");
    }
    @Override
    public void onFailure(CopyObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
        // Request exception
        if (clientExcepion != null) {
            // Local exception, such as a network exception
            clientExcepion.printStackTrace();
        }
        if (serviceException != null) {
            // Service exception
            Log.e("ErrorCode", serviceException.getErrorCode());
            Log.e("RequestId", serviceException.getRequestId());
            Log.e("HostId", serviceException.getHostId());
            Log.e("RawMessage", serviceException.getRawMessage());
        }
    }
});

When you use the preceding code to copy any object, consider the following points:

• The source object and target object must belong to the same data center.

• In the COPY operation, if the source object address and target object address are same, you can modify the meta information of the existing object.

• The object to be copied must not exceed 1 GB. Otherwise, you are required to upload it through multipart upload.

Delete an object

// Create a DELETE request
DeleteObjectRequest delete = new DeleteObjectRequest("<bucketName>", "<objectKey>");
// Asynchronous deletion
OSSAsyncTask deleteTask = oss.asyncDeleteObject(delete, new OSSCompletedCallback<DeleteObjectRequest, DeleteObjectResult>() {
    @Override
    public void onSuccess(DeleteObjectRequest request, DeleteObjectResult result) {
        Log.d("asyncCopyAndDelObject", "success!");
    }
    @Override
    public void onFailure(DeleteObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
        // Request exception
        if (clientExcepion != null) {
            // Local exception, such as a network exception
            clientExcepion.printStackTrace();
        }
        if (serviceException != null) {
            // Service exception
            Log.e("ErrorCode", serviceException.getErrorCode());
            Log.e("RequestId", serviceException.getRequestId());
            Log.e("HostId", serviceException.getHostId());
            Log.e("RawMessage", serviceException.getRawMessage());
        }
    }
});

When you use the preceding code to delete any object, consider the following point:

• To delete an object with DeleteObject, you must have the write permission on the bucket that stores the object.

Retrieve the object metadata only

The following code obtains the metadata of an object:

// Create a request for synchronously obtaining object metadata
HeadObjectRequest head = new HeadObjectRequest("<bucketName>", "<objectKey>");
OSSAsyncTask task = oss.asyncHeadObject(head, new OSSCompletedCallback<HeadObjectRequest, HeadObjectResult>() {
    @Override
    public void onSuccess(HeadObjectRequest request, HeadObjectResult result) {
        Log.d("headObject", "object Size: " + result.getMetadata().getContentLength()); // Get the object length
        Log.d("headObject", "object Content Type: " + result.getMetadata().getContentType()); // Obtain the object type
    }
    @Override
    public void onFailure(HeadObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
        // Request exception
        if (clientExcepion != null) {
            // Local exception, such as a network exception
            clientExcepion.printStackTrace();
        }
        if (serviceException != null) {
            // Service exception
            Log.e("ErrorCode", serviceException.getErrorCode());
            Log.e("RequestId", serviceException.getRequestId());
            Log.e("HostId", serviceException.getHostId());
            Log.e("RawMessage", serviceException.getRawMessage());
        }
    }
});
// task.waitUntilFinished();