Android跟踪Azure CloudBlockBlob上传的进度

Question

How can I print the number of bytes that have been uploaded after calling blob.upload(new FileInputStream(imageFile), imageFile.length()); I want to log something like "100/totalBytes bytes have been uploaded, 224/totalBytes bytes have been uploaded..." So I can create a progress bar of the upload progress.

this is the code:

//AzureBlobLoader extends AsyncTask

public class AzureBlobUploader extends AzureBlobLoader {
private Activity act;
private String userName;
private TaggedImageObject img;
private Fragment histFragment;

public AzureBlobUploader(Fragment f, Activity act, String userName, TaggedImageObject img) {
    super();
    this.act = act;
    this.userName = userName;
    this.img = img;
    this.histFragment = f;
}


@Override
protected Object doInBackground(Object[] params) {

    File imageFile = new File(this.img.getImgPath());

    try {

        // Define the path to a local file.
        final String filePath = imageFile.getPath();

        // Create or overwrite the blob with contents from the local file.
        String[] imagePathArray = filePath.split("/");
        String imageName = imagePathArray[imagePathArray.length-1];

        System.out.println("Image Name: " + imageName);

        String containerName = userName + "/" + imageName;

        System.out.println("Container Name: " + containerName);

        CloudBlockBlob blob= this.getContainer().getBlockBlobReference(containerName);


        //UPLOAD!
       blob.upload(new FileInputStream(imageFile), imageFile.length());

        //-----DATABASE-----//
        //create client
        this.setDBClient(
                new MobileServiceClient(
                        "URL",
                        this.act.getApplicationContext()
                )
        );

        this.setImageTable(this.getDBClient().getTable(Image.class));
        this.setIcavTable(this.getDBClient().getTable(ICAV.class));

        //IMG TABLE QUERY
        String validImageID = containerName.replace("/", "_");
        Log.d("Azure", "Valid Image ID: " + validImageID);

        Image img = new Image(validImageID, this.img.getUser(), this.img.getLat(), this.img.getLon());
        this.getImageTable().insert(img);

        for(String context : this.img.getContextAttributeMap().keySet()){
            Map<String,String> attributeValueMap = this.img.getContextAttributeMap().get(context);

            for(String attribute : attributeValueMap.keySet()){
                String value = attributeValueMap.get(attribute);


                ICAV icavRow = new ICAV();
                icavRow.setImageID(validImageID);
                icavRow.setContextID(context);
                icavRow.setAttributeID(attribute);
                icavRow.setValue(value);

                this.getIcavTable().insert(icavRow);
            }

        }
    } catch (Exception e) {
        System.out.println(e.toString());
    }

    return null;
}



@Override
protected void onProgressUpdate(Object... object) {
    super.onProgressUpdate(object);
    Log.d("progressUpdate", "progress: "+((Integer)object[0] * 2) + "%");
}

@Override
protected void onPostExecute(Object o) {
    // to do


}

}

Answer 1

As you can see the Azure SDK doesn't directly allow for that, but it should be fairly easy to wrap your inputstream in another input stream that can give callbacks for bytes read. Something like that:

public class ListenableInputStream extends InputStream {

    private final InputStream wraped;
    private final ReadListener listener;
    private final long minimumBytesPerCall;
    private long bytesRead;

    public ListenableInputStream(InputStream wraped, ReadListener listener, int minimumBytesPerCall) {
        this.wraped = wraped;
        this.listener = listener;
        this.minimumBytesPerCall = minimumBytesPerCall;
    }


    @Override
    public int read() throws IOException {
        int read = wraped.read();
        if (read >= 0) {
            bytesRead++;
        }
        if (bytesRead > minimumBytesPerCall || read == -1) {
            listener.onRead(bytesRead);
            bytesRead = 0;
        }
        return read;
    }

    @Override
    public int available() throws IOException {
        return wraped.available();
    }

    @Override
    public void close() throws IOException {
        wraped.close();
    }

    @Override
    public synchronized void mark(int readlimit) {
        wraped.mark(readlimit);
    }

    @Override
    public synchronized void reset() throws IOException {
        wraped.reset();
    }

    @Override
    public boolean markSupported() {
        return wraped.markSupported();
    }

    interface ReadListener {
        void onRead(long bytes);
    }
}

minimumBytesPerCall should be initialised with some sensible number, as you probably don't want to be called on every single byte, maybe every half a megabyte should be good.

And remember that this all gets called on the doInBackground thread, so act accordingly.

edit:

I've edited the class above, there was a small error on computing the bytesRead value. The official documentation explains your follow-up questions https://developer.android.com/reference/java/io/InputStream.html#read()

Reads the next byte of data from the input stream

So read() reads 1 byte of data (or return -1) if reached the end. So yes, it must be called several several times to read a whole image.

Then the method onRead(long) get's called every time at least minimumBytesPerCall have been read (that's to avoid of calling back for every single byte) and once more at the end of the stream (when it returns -1)

The value passed to onRead(long) is the amount that have been read since the last call. So implementing this on your AsyncTask you would have to accumulate this value and compare with the total size of the file.

Something like the following code inside your asynctask should work fine (assuming the Progress generic parameter is a Long):

    private long fileLength;
    private long totalBytes;

    private final ListenableInputStream.ReadListener readListener = new ListenableInputStream.ReadListener() {
        @Override
        public void onRead(long bytes) {
            totalBytes += bytes;
            publishProgress(totalBytes);
        }
    };

and on inside your upload part you replace with:

FileInputStream fis = new FileInputStream(imageFile);
fileLength = imageFile.length();
ListenableInputStream lis = new ListenableInputStream(fi, readListener, 256 * 1024); // this will call onRead(long) every 256kb
blob.upload(lis, fileLength);

and as a last remark, remember that internally the CloudBlockBlob just caching the file on its own memory for later upload, or doing any other weird stuff that is out of your control. All this code does is check that the complete file was read.

happy coding!

Answer 2

Just another way for your needs, there is a MS blog which introduce about uploading a blob to Azure Storage with progress bar and variable upload block size . That code was written in C#, but it's very simple for reading by Java/Android Developer, I think you can easily rewrite it in Java for Android to compute the uploading processbar ratio to share via some public variables.

Hope it helps.