Before monitoring an Uri, one needs to call monitorUri to record the file group that Uri * belongs to at the downloading time. * *
Currently we only support 1 DownloadListener per File Group.
*/
@ThreadSafe
public class DownloadProgressMonitor implements Monitor, SingleFileDownloadProgressMonitor {
private static final String TAG = "DownloadProgressMonitor";
private final TimeSource timeSource;
private final Executor sequentialControlExecutor;
private final com.google.android.libraries.mobiledatadownload.lite.DownloadProgressMonitor
liteDownloadProgressMonitor;
public DownloadProgressMonitor(TimeSource timeSource, Executor controlExecutor) {
this.timeSource = timeSource;
// We want onProgress to be executed in order otherwise clients will observe out of order
// updates (bigger current size update appears before smaller current size update).
// We use Sequential Executor to ensure the onProgress will be processed sequentially.
this.sequentialControlExecutor = MoreExecutors.newSequentialExecutor(controlExecutor);
// Construct internal instance of MDD Lite's DownloadProgressMonitor. methods of
// SingleFileDownloadProgressMonitor will delegate to this instance.
this.liteDownloadProgressMonitor =
com.google.android.libraries.mobiledatadownload.lite.DownloadProgressMonitor.create(
this.timeSource, controlExecutor);
}
// We will only broadcast on progress notification at most once in this time frame.
// Currently MobStore Monitor notify every 8KB of downloaded bytes. This may be too chatty on
// fast network.
// 1 second was chosen arbitrarily.
@VisibleForTesting static final long LOG_FREQUENCY = 1000L;
// MobStore Monitor works at file level. We want to monitor at FileGroup level. This map will
// help to map from a fileUri to a file group.
@GuardedBy("DownloadProgressMonitor.class")
private final HashMap Currently we only support 1 listener per file group. Calling addDownloadListener to add
* another listener would be no-op.
*
* @param groupName The groupName that the DownloadListener will receive download progress update.
* @param downloadListener the DownloadListener to add.
*/
public void addDownloadListener(String groupName, DownloadListener downloadListener) {
synchronized (DownloadProgressMonitor.class) {
if (!fileGroupToByteCountingOutputMonitor.containsKey(groupName)) {
fileGroupToByteCountingOutputMonitor.put(
groupName,
new ByteCountingOutputMonitor(
new DownloadedBytesCounter(groupName, downloadListener),
timeSource::currentTimeMillis,
LOG_FREQUENCY,
TimeUnit.MILLISECONDS));
}
}
}
/**
* Add a Single File DownloadListener.
*
* This listener allows clients to receive on progress updates for single file downloads.
*
* @param uri the uri for which the DownloadListener should receive updates
* @param downloadListener the MDD Lite DownloadListener to add
*/
@Override
public void addDownloadListener(
Uri uri,
com.google.android.libraries.mobiledatadownload.lite.DownloadListener downloadListener) {
liteDownloadProgressMonitor.addDownloadListener(uri, downloadListener);
}
/**
* Remove a File Group DownloadListener.
*
* @param groupName The groupName that the DownloadListener receive download progress update.
*/
public void removeDownloadListener(String groupName) {
synchronized (DownloadProgressMonitor.class) {
fileGroupToByteCountingOutputMonitor.remove(groupName);
}
}
/**
* Remove a Single File DownloadListener.
*
* @param uri the uri which should be cleared of any registered DownloadListener
*/
@Override
public void removeDownloadListener(Uri uri) {
liteDownloadProgressMonitor.removeDownloadListener(uri);
}
/**
* Record that the Uri belong to the FileGroup represented by groupName. We need to record this at
* downloading time since the files in FileGroup could change due to config change. monitorUri
* should only be called for files that have not been downloaded.
*
* @param uri the FileUri to be monitored.
* @param groupName the group name to be monitored.
*/
public void monitorUri(Uri uri, String groupName) {
synchronized (DownloadProgressMonitor.class) {
uriToFileGroup.put(uri, groupName);
}
}
/**
* Add the current size of a downloaded or partially downloaded file to a file group counter.
*
* @param groupName the group name to add the current size.
* @param currentSize the current size of the file.
*/
public void notifyCurrentFileSize(String groupName, long currentSize) {
synchronized (DownloadProgressMonitor.class) {
// Update the counter with the current size.
if (fileGroupToByteCountingOutputMonitor.containsKey(groupName)) {
fileGroupToByteCountingOutputMonitor
.get(groupName)
.getCounter()
.bufferCounter((int) currentSize);
}
}
}
// A counter for bytes downloaded.
private final class DownloadedBytesCounter implements ByteCountingOutputMonitor.Counter {
private final String groupName;
private final DownloadListener downloadListener;
private final AtomicLong byteCounter = new AtomicLong();
DownloadedBytesCounter(String groupName, DownloadListener downloadListener) {
this.groupName = groupName;
this.downloadListener = downloadListener;
}
@Override
public void bufferCounter(int len) {
byteCounter.getAndAdd(len);
LogUtil.v(
"%s: Received data for groupName = %s, len = %d, Counter = %d",
TAG, groupName, len, byteCounter.get());
}
@Override
public void flushCounter() {
// Check if the DownloadListener is still being used before calling its onProgress.
synchronized (DownloadProgressMonitor.class) {
if (fileGroupToByteCountingOutputMonitor.containsKey(groupName)) {
sequentialControlExecutor.execute(() -> downloadListener.onProgress(byteCounter.get()));
}
}
}
public void pausedForConnectivity() {
downloadListener.pausedForConnectivity();
}
}
}