Implement multi-network downloads
[android/platform/packages/providers/DownloadProvider.git] / src / com / android / providers / downloads / DownloadThread.java
1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.android.providers.downloads;
18
19 import static android.provider.Downloads.Impl.STATUS_BAD_REQUEST;
20 import static android.provider.Downloads.Impl.STATUS_CANCELED;
21 import static android.provider.Downloads.Impl.STATUS_CANNOT_RESUME;
22 import static android.provider.Downloads.Impl.STATUS_FILE_ERROR;
23 import static android.provider.Downloads.Impl.STATUS_HTTP_DATA_ERROR;
24 import static android.provider.Downloads.Impl.STATUS_SUCCESS;
25 import static android.provider.Downloads.Impl.STATUS_TOO_MANY_REDIRECTS;
26 import static android.provider.Downloads.Impl.STATUS_UNHANDLED_HTTP_CODE;
27 import static android.provider.Downloads.Impl.STATUS_UNKNOWN_ERROR;
28 import static android.provider.Downloads.Impl.STATUS_WAITING_FOR_NETWORK;
29 import static android.provider.Downloads.Impl.STATUS_WAITING_TO_RETRY;
30 import static android.text.format.DateUtils.SECOND_IN_MILLIS;
31 import static com.android.providers.downloads.Constants.TAG;
32 import static java.net.HttpURLConnection.HTTP_INTERNAL_ERROR;
33 import static java.net.HttpURLConnection.HTTP_MOVED_PERM;
34 import static java.net.HttpURLConnection.HTTP_MOVED_TEMP;
35 import static java.net.HttpURLConnection.HTTP_OK;
36 import static java.net.HttpURLConnection.HTTP_PARTIAL;
37 import static java.net.HttpURLConnection.HTTP_PRECON_FAILED;
38 import static java.net.HttpURLConnection.HTTP_SEE_OTHER;
39 import static java.net.HttpURLConnection.HTTP_UNAVAILABLE;
40
41 import android.content.ContentValues;
42 import android.content.Context;
43 import android.content.Intent;
44 import android.drm.DrmManagerClient;
45 import android.drm.DrmOutputStream;
46 import android.net.ConnectivityManager;
47 import android.net.INetworkPolicyListener;
48 import android.net.Network;
49 import android.net.NetworkInfo;
50 import android.net.NetworkPolicyManager;
51 import android.net.TrafficStats;
52 import android.net.Uri;
53 import android.os.ParcelFileDescriptor;
54 import android.os.PowerManager;
55 import android.os.Process;
56 import android.os.SystemClock;
57 import android.os.WorkSource;
58 import android.provider.Downloads;
59 import android.system.ErrnoException;
60 import android.system.Os;
61 import android.system.OsConstants;
62 import android.util.Log;
63 import android.util.Pair;
64
65 import com.android.providers.downloads.DownloadInfo.NetworkState;
66
67 import libcore.io.IoUtils;
68
69 import java.io.File;
70 import java.io.FileDescriptor;
71 import java.io.FileNotFoundException;
72 import java.io.IOException;
73 import java.io.InputStream;
74 import java.io.OutputStream;
75 import java.net.HttpURLConnection;
76 import java.net.MalformedURLException;
77 import java.net.ProtocolException;
78 import java.net.URL;
79 import java.net.URLConnection;
80
81 /**
82  * Task which executes a given {@link DownloadInfo}: making network requests,
83  * persisting data to disk, and updating {@link DownloadProvider}.
84  * <p>
85  * To know if a download is successful, we need to know either the final content
86  * length to expect, or the transfer to be chunked. To resume an interrupted
87  * download, we need an ETag.
88  * <p>
89  * Failed network requests are retried several times before giving up. Local
90  * disk errors fail immediately and are not retried.
91  */
92 public class DownloadThread implements Runnable {
93
94     // TODO: bind each download to a specific network interface to avoid state
95     // checking races once we have ConnectivityManager API
96
97     // TODO: add support for saving to content://
98
99     private static final int HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
100     private static final int HTTP_TEMP_REDIRECT = 307;
101
102     private static final int DEFAULT_TIMEOUT = (int) (20 * SECOND_IN_MILLIS);
103
104     private final Context mContext;
105     private final SystemFacade mSystemFacade;
106     private final DownloadNotifier mNotifier;
107
108     private final long mId;
109
110     /**
111      * Info object that should be treated as read-only. Any potentially mutated
112      * fields are tracked in {@link #mInfoDelta}. If a field exists in
113      * {@link #mInfoDelta}, it must not be read from {@link #mInfo}.
114      */
115     private final DownloadInfo mInfo;
116     private final DownloadInfoDelta mInfoDelta;
117
118     private volatile boolean mPolicyDirty;
119
120     /**
121      * Local changes to {@link DownloadInfo}. These are kept local to avoid
122      * racing with the thread that updates based on change notifications.
123      */
124     private class DownloadInfoDelta {
125         public String mUri;
126         public String mFileName;
127         public String mMimeType;
128         public int mStatus;
129         public int mNumFailed;
130         public int mRetryAfter;
131         public long mTotalBytes;
132         public long mCurrentBytes;
133         public String mETag;
134
135         public String mErrorMsg;
136
137         public DownloadInfoDelta(DownloadInfo info) {
138             mUri = info.mUri;
139             mFileName = info.mFileName;
140             mMimeType = info.mMimeType;
141             mStatus = info.mStatus;
142             mNumFailed = info.mNumFailed;
143             mRetryAfter = info.mRetryAfter;
144             mTotalBytes = info.mTotalBytes;
145             mCurrentBytes = info.mCurrentBytes;
146             mETag = info.mETag;
147         }
148
149         private ContentValues buildContentValues() {
150             final ContentValues values = new ContentValues();
151
152             values.put(Downloads.Impl.COLUMN_URI, mUri);
153             values.put(Downloads.Impl._DATA, mFileName);
154             values.put(Downloads.Impl.COLUMN_MIME_TYPE, mMimeType);
155             values.put(Downloads.Impl.COLUMN_STATUS, mStatus);
156             values.put(Downloads.Impl.COLUMN_FAILED_CONNECTIONS, mNumFailed);
157             values.put(Constants.RETRY_AFTER_X_REDIRECT_COUNT, mRetryAfter);
158             values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, mTotalBytes);
159             values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, mCurrentBytes);
160             values.put(Constants.ETAG, mETag);
161
162             values.put(Downloads.Impl.COLUMN_LAST_MODIFICATION, mSystemFacade.currentTimeMillis());
163             values.put(Downloads.Impl.COLUMN_ERROR_MSG, mErrorMsg);
164
165             return values;
166         }
167
168         /**
169          * Blindly push update of current delta values to provider.
170          */
171         public void writeToDatabase() {
172             mContext.getContentResolver().update(mInfo.getAllDownloadsUri(), buildContentValues(),
173                     null, null);
174         }
175
176         /**
177          * Push update of current delta values to provider, asserting strongly
178          * that we haven't been paused or deleted.
179          */
180         public void writeToDatabaseOrThrow() throws StopRequestException {
181             if (mContext.getContentResolver().update(mInfo.getAllDownloadsUri(),
182                     buildContentValues(), Downloads.Impl.COLUMN_DELETED + " == '0'", null) == 0) {
183                 throw new StopRequestException(STATUS_CANCELED, "Download deleted or missing!");
184             }
185         }
186     }
187
188     /**
189      * Flag indicating if we've made forward progress transferring file data
190      * from a remote server.
191      */
192     private boolean mMadeProgress = false;
193
194     /**
195      * Details from the last time we pushed a database update.
196      */
197     private long mLastUpdateBytes = 0;
198     private long mLastUpdateTime = 0;
199
200     private int mNetworkType = ConnectivityManager.TYPE_NONE;
201
202     /** Historical bytes/second speed of this download. */
203     private long mSpeed;
204     /** Time when current sample started. */
205     private long mSpeedSampleStart;
206     /** Bytes transferred since current sample started. */
207     private long mSpeedSampleBytes;
208
209     public DownloadThread(Context context, SystemFacade systemFacade, DownloadNotifier notifier,
210             DownloadInfo info) {
211         mContext = context;
212         mSystemFacade = systemFacade;
213         mNotifier = notifier;
214
215         mId = info.mId;
216         mInfo = info;
217         mInfoDelta = new DownloadInfoDelta(info);
218     }
219
220     @Override
221     public void run() {
222         Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
223
224         // Skip when download already marked as finished; this download was
225         // probably started again while racing with UpdateThread.
226         if (DownloadInfo.queryDownloadStatus(mContext.getContentResolver(), mId)
227                 == Downloads.Impl.STATUS_SUCCESS) {
228             logDebug("Already finished; skipping");
229             return;
230         }
231
232         final NetworkPolicyManager netPolicy = NetworkPolicyManager.from(mContext);
233         PowerManager.WakeLock wakeLock = null;
234         final PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
235
236         try {
237             wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, Constants.TAG);
238             wakeLock.setWorkSource(new WorkSource(mInfo.mUid));
239             wakeLock.acquire();
240
241             // while performing download, register for rules updates
242             netPolicy.registerListener(mPolicyListener);
243
244             logDebug("Starting");
245
246             // Remember which network this download started on; used to
247             // determine if errors were due to network changes.
248             final NetworkInfo info = mSystemFacade.getActiveNetworkInfo(mInfo.mUid);
249             if (info != null) {
250                 mNetworkType = info.getType();
251             }
252
253             // Network traffic on this thread should be counted against the
254             // requesting UID, and is tagged with well-known value.
255             TrafficStats.setThreadStatsTag(TrafficStats.TAG_SYSTEM_DOWNLOAD);
256             TrafficStats.setThreadStatsUid(mInfo.mUid);
257
258             executeDownload();
259
260             mInfoDelta.mStatus = STATUS_SUCCESS;
261             TrafficStats.incrementOperationCount(1);
262
263             // If we just finished a chunked file, record total size
264             if (mInfoDelta.mTotalBytes == -1) {
265                 mInfoDelta.mTotalBytes = mInfoDelta.mCurrentBytes;
266             }
267
268         } catch (StopRequestException e) {
269             mInfoDelta.mStatus = e.getFinalStatus();
270             mInfoDelta.mErrorMsg = e.getMessage();
271
272             logWarning("Stop requested with status "
273                     + Downloads.Impl.statusToString(mInfoDelta.mStatus) + ": "
274                     + mInfoDelta.mErrorMsg);
275
276             // Nobody below our level should request retries, since we handle
277             // failure counts at this level.
278             if (mInfoDelta.mStatus == STATUS_WAITING_TO_RETRY) {
279                 throw new IllegalStateException("Execution should always throw final error codes");
280             }
281
282             // Some errors should be retryable, unless we fail too many times.
283             if (isStatusRetryable(mInfoDelta.mStatus)) {
284                 if (mMadeProgress) {
285                     mInfoDelta.mNumFailed = 1;
286                 } else {
287                     mInfoDelta.mNumFailed += 1;
288                 }
289
290                 if (mInfoDelta.mNumFailed < Constants.MAX_RETRIES) {
291                     final NetworkInfo info = mSystemFacade.getActiveNetworkInfo(mInfo.mUid);
292                     if (info != null && info.getType() == mNetworkType && info.isConnected()) {
293                         // Underlying network is still intact, use normal backoff
294                         mInfoDelta.mStatus = STATUS_WAITING_TO_RETRY;
295                     } else {
296                         // Network changed, retry on any next available
297                         mInfoDelta.mStatus = STATUS_WAITING_FOR_NETWORK;
298                     }
299
300                     if ((mInfoDelta.mETag == null && mMadeProgress)
301                             || DownloadDrmHelper.isDrmConvertNeeded(mInfoDelta.mMimeType)) {
302                         // However, if we wrote data and have no ETag to verify
303                         // contents against later, we can't actually resume.
304                         mInfoDelta.mStatus = STATUS_CANNOT_RESUME;
305                     }
306                 }
307             }
308
309         } catch (Throwable t) {
310             mInfoDelta.mStatus = STATUS_UNKNOWN_ERROR;
311             mInfoDelta.mErrorMsg = t.toString();
312
313             logError("Failed: " + mInfoDelta.mErrorMsg, t);
314
315         } finally {
316             logDebug("Finished with status " + Downloads.Impl.statusToString(mInfoDelta.mStatus));
317
318             mNotifier.notifyDownloadSpeed(mId, 0);
319
320             finalizeDestination();
321
322             mInfoDelta.writeToDatabase();
323
324             if (Downloads.Impl.isStatusCompleted(mInfoDelta.mStatus)) {
325                 mInfo.sendIntentIfRequested();
326             }
327
328             TrafficStats.clearThreadStatsTag();
329             TrafficStats.clearThreadStatsUid();
330
331             netPolicy.unregisterListener(mPolicyListener);
332
333             if (wakeLock != null) {
334                 wakeLock.release();
335                 wakeLock = null;
336             }
337         }
338     }
339
340     /**
341      * Fully execute a single download request. Setup and send the request,
342      * handle the response, and transfer the data to the destination file.
343      */
344     private void executeDownload() throws StopRequestException {
345         final boolean resuming = mInfoDelta.mCurrentBytes != 0;
346
347         URL url;
348         try {
349             // TODO: migrate URL sanity checking into client side of API
350             url = new URL(mInfoDelta.mUri);
351         } catch (MalformedURLException e) {
352             throw new StopRequestException(STATUS_BAD_REQUEST, e);
353         }
354
355         final Network network = mSystemFacade.getActiveNetwork(mInfo.mUid);
356         if (network == null) {
357             throw new StopRequestException(Downloads.Impl.STATUS_WAITING_FOR_NETWORK,
358                     "no network associated with requesting UID");
359         }
360         logDebug("Using network: " + network);
361
362         boolean cleartextTrafficPermitted = mSystemFacade.isCleartextTrafficPermitted(mInfo.mUid);
363         int redirectionCount = 0;
364         while (redirectionCount++ < Constants.MAX_REDIRECTS) {
365             // Enforce the cleartext traffic opt-out for the UID. This cannot be enforced earlier
366             // because of HTTP redirects which can change the protocol between HTTP and HTTPS.
367             if ((!cleartextTrafficPermitted) && ("http".equalsIgnoreCase(url.getProtocol()))) {
368                 throw new StopRequestException(STATUS_BAD_REQUEST,
369                         "Cleartext traffic not permitted for UID " + mInfo.mUid + ": "
370                         + Uri.parse(url.toString()).toSafeString());
371             }
372
373             // Open connection and follow any redirects until we have a useful
374             // response with body.
375             HttpURLConnection conn = null;
376             try {
377                 checkConnectivity();
378                 conn = (HttpURLConnection) network.openConnection(url);
379                 conn.setInstanceFollowRedirects(false);
380                 conn.setConnectTimeout(DEFAULT_TIMEOUT);
381                 conn.setReadTimeout(DEFAULT_TIMEOUT);
382
383                 addRequestHeaders(conn, resuming);
384
385                 final int responseCode = conn.getResponseCode();
386                 switch (responseCode) {
387                     case HTTP_OK:
388                         if (resuming) {
389                             throw new StopRequestException(
390                                     STATUS_CANNOT_RESUME, "Expected partial, but received OK");
391                         }
392                         parseOkHeaders(conn);
393                         transferData(conn);
394                         return;
395
396                     case HTTP_PARTIAL:
397                         if (!resuming) {
398                             throw new StopRequestException(
399                                     STATUS_CANNOT_RESUME, "Expected OK, but received partial");
400                         }
401                         transferData(conn);
402                         return;
403
404                     case HTTP_MOVED_PERM:
405                     case HTTP_MOVED_TEMP:
406                     case HTTP_SEE_OTHER:
407                     case HTTP_TEMP_REDIRECT:
408                         final String location = conn.getHeaderField("Location");
409                         url = new URL(url, location);
410                         if (responseCode == HTTP_MOVED_PERM) {
411                             // Push updated URL back to database
412                             mInfoDelta.mUri = url.toString();
413                         }
414                         continue;
415
416                     case HTTP_PRECON_FAILED:
417                         throw new StopRequestException(
418                                 STATUS_CANNOT_RESUME, "Precondition failed");
419
420                     case HTTP_REQUESTED_RANGE_NOT_SATISFIABLE:
421                         throw new StopRequestException(
422                                 STATUS_CANNOT_RESUME, "Requested range not satisfiable");
423
424                     case HTTP_UNAVAILABLE:
425                         parseUnavailableHeaders(conn);
426                         throw new StopRequestException(
427                                 HTTP_UNAVAILABLE, conn.getResponseMessage());
428
429                     case HTTP_INTERNAL_ERROR:
430                         throw new StopRequestException(
431                                 HTTP_INTERNAL_ERROR, conn.getResponseMessage());
432
433                     default:
434                         StopRequestException.throwUnhandledHttpError(
435                                 responseCode, conn.getResponseMessage());
436                 }
437
438             } catch (IOException e) {
439                 if (e instanceof ProtocolException
440                         && e.getMessage().startsWith("Unexpected status line")) {
441                     throw new StopRequestException(STATUS_UNHANDLED_HTTP_CODE, e);
442                 } else {
443                     // Trouble with low-level sockets
444                     throw new StopRequestException(STATUS_HTTP_DATA_ERROR, e);
445                 }
446
447             } finally {
448                 if (conn != null) conn.disconnect();
449             }
450         }
451
452         throw new StopRequestException(STATUS_TOO_MANY_REDIRECTS, "Too many redirects");
453     }
454
455     /**
456      * Transfer data from the given connection to the destination file.
457      */
458     private void transferData(HttpURLConnection conn) throws StopRequestException {
459
460         // To detect when we're really finished, we either need a length, closed
461         // connection, or chunked encoding.
462         final boolean hasLength = mInfoDelta.mTotalBytes != -1;
463         final boolean isConnectionClose = "close".equalsIgnoreCase(
464                 conn.getHeaderField("Connection"));
465         final boolean isEncodingChunked = "chunked".equalsIgnoreCase(
466                 conn.getHeaderField("Transfer-Encoding"));
467
468         final boolean finishKnown = hasLength || isConnectionClose || isEncodingChunked;
469         if (!finishKnown) {
470             throw new StopRequestException(
471                     STATUS_CANNOT_RESUME, "can't know size of download, giving up");
472         }
473
474         DrmManagerClient drmClient = null;
475         ParcelFileDescriptor outPfd = null;
476         FileDescriptor outFd = null;
477         InputStream in = null;
478         OutputStream out = null;
479         try {
480             try {
481                 in = conn.getInputStream();
482             } catch (IOException e) {
483                 throw new StopRequestException(STATUS_HTTP_DATA_ERROR, e);
484             }
485
486             try {
487                 outPfd = mContext.getContentResolver()
488                         .openFileDescriptor(mInfo.getAllDownloadsUri(), "rw");
489                 outFd = outPfd.getFileDescriptor();
490
491                 if (DownloadDrmHelper.isDrmConvertNeeded(mInfoDelta.mMimeType)) {
492                     drmClient = new DrmManagerClient(mContext);
493                     out = new DrmOutputStream(drmClient, outPfd, mInfoDelta.mMimeType);
494                 } else {
495                     out = new ParcelFileDescriptor.AutoCloseOutputStream(outPfd);
496                 }
497
498                 // Pre-flight disk space requirements, when known
499                 if (mInfoDelta.mTotalBytes > 0) {
500                     final long curSize = Os.fstat(outFd).st_size;
501                     final long newBytes = mInfoDelta.mTotalBytes - curSize;
502
503                     StorageUtils.ensureAvailableSpace(mContext, outFd, newBytes);
504
505                     try {
506                         // We found enough space, so claim it for ourselves
507                         Os.posix_fallocate(outFd, 0, mInfoDelta.mTotalBytes);
508                     } catch (ErrnoException e) {
509                         if (e.errno == OsConstants.ENOSYS || e.errno == OsConstants.ENOTSUP) {
510                             Log.w(TAG, "fallocate() not supported; falling back to ftruncate()");
511                             Os.ftruncate(outFd, mInfoDelta.mTotalBytes);
512                         } else {
513                             throw e;
514                         }
515                     }
516                 }
517
518                 // Move into place to begin writing
519                 Os.lseek(outFd, mInfoDelta.mCurrentBytes, OsConstants.SEEK_SET);
520
521             } catch (ErrnoException e) {
522                 throw new StopRequestException(STATUS_FILE_ERROR, e);
523             } catch (IOException e) {
524                 throw new StopRequestException(STATUS_FILE_ERROR, e);
525             }
526
527             // Start streaming data, periodically watch for pause/cancel
528             // commands and checking disk space as needed.
529             transferData(in, out, outFd);
530
531             try {
532                 if (out instanceof DrmOutputStream) {
533                     ((DrmOutputStream) out).finish();
534                 }
535             } catch (IOException e) {
536                 throw new StopRequestException(STATUS_FILE_ERROR, e);
537             }
538
539         } finally {
540             if (drmClient != null) {
541                 drmClient.release();
542             }
543
544             IoUtils.closeQuietly(in);
545
546             try {
547                 if (out != null) out.flush();
548                 if (outFd != null) outFd.sync();
549             } catch (IOException e) {
550             } finally {
551                 IoUtils.closeQuietly(out);
552             }
553         }
554     }
555
556     /**
557      * Transfer as much data as possible from the HTTP response to the
558      * destination file.
559      */
560     private void transferData(InputStream in, OutputStream out, FileDescriptor outFd)
561             throws StopRequestException {
562         final byte buffer[] = new byte[Constants.BUFFER_SIZE];
563         while (true) {
564             checkPausedOrCanceled();
565
566             int len = -1;
567             try {
568                 len = in.read(buffer);
569             } catch (IOException e) {
570                 throw new StopRequestException(
571                         STATUS_HTTP_DATA_ERROR, "Failed reading response: " + e, e);
572             }
573
574             if (len == -1) {
575                 break;
576             }
577
578             try {
579                 // When streaming, ensure space before each write
580                 if (mInfoDelta.mTotalBytes == -1) {
581                     final long curSize = Os.fstat(outFd).st_size;
582                     final long newBytes = (mInfoDelta.mCurrentBytes + len) - curSize;
583
584                     StorageUtils.ensureAvailableSpace(mContext, outFd, newBytes);
585                 }
586
587                 out.write(buffer, 0, len);
588
589                 mMadeProgress = true;
590                 mInfoDelta.mCurrentBytes += len;
591
592                 updateProgress(outFd);
593
594             } catch (ErrnoException e) {
595                 throw new StopRequestException(STATUS_FILE_ERROR, e);
596             } catch (IOException e) {
597                 throw new StopRequestException(STATUS_FILE_ERROR, e);
598             }
599         }
600
601         // Finished without error; verify length if known
602         if (mInfoDelta.mTotalBytes != -1 && mInfoDelta.mCurrentBytes != mInfoDelta.mTotalBytes) {
603             throw new StopRequestException(STATUS_HTTP_DATA_ERROR, "Content length mismatch");
604         }
605     }
606
607     /**
608      * Called just before the thread finishes, regardless of status, to take any
609      * necessary action on the downloaded file.
610      */
611     private void finalizeDestination() {
612         if (Downloads.Impl.isStatusError(mInfoDelta.mStatus)) {
613             // When error, free up any disk space
614             try {
615                 final ParcelFileDescriptor target = mContext.getContentResolver()
616                         .openFileDescriptor(mInfo.getAllDownloadsUri(), "rw");
617                 try {
618                     Os.ftruncate(target.getFileDescriptor(), 0);
619                 } catch (ErrnoException ignored) {
620                 } finally {
621                     IoUtils.closeQuietly(target);
622                 }
623             } catch (FileNotFoundException ignored) {
624             }
625
626             // Delete if local file
627             if (mInfoDelta.mFileName != null) {
628                 new File(mInfoDelta.mFileName).delete();
629                 mInfoDelta.mFileName = null;
630             }
631
632         } else if (Downloads.Impl.isStatusSuccess(mInfoDelta.mStatus)) {
633             // When success, open access if local file
634             if (mInfoDelta.mFileName != null) {
635                 if (mInfo.mDestination != Downloads.Impl.DESTINATION_FILE_URI) {
636                     try {
637                         // Move into final resting place, if needed
638                         final File before = new File(mInfoDelta.mFileName);
639                         final File beforeDir = Helpers.getRunningDestinationDirectory(
640                                 mContext, mInfo.mDestination);
641                         final File afterDir = Helpers.getSuccessDestinationDirectory(
642                                 mContext, mInfo.mDestination);
643                         if (!beforeDir.equals(afterDir)
644                                 && before.getParentFile().equals(beforeDir)) {
645                             final File after = new File(afterDir, before.getName());
646                             if (before.renameTo(after)) {
647                                 mInfoDelta.mFileName = after.getAbsolutePath();
648                             }
649                         }
650                     } catch (IOException ignored) {
651                     }
652                 }
653             }
654         }
655     }
656
657     /**
658      * Check if current connectivity is valid for this request.
659      */
660     private void checkConnectivity() throws StopRequestException {
661         // checking connectivity will apply current policy
662         mPolicyDirty = false;
663
664         final NetworkState networkUsable = mInfo.checkCanUseNetwork(mInfoDelta.mTotalBytes);
665         if (networkUsable != NetworkState.OK) {
666             int status = Downloads.Impl.STATUS_WAITING_FOR_NETWORK;
667             if (networkUsable == NetworkState.UNUSABLE_DUE_TO_SIZE) {
668                 status = Downloads.Impl.STATUS_QUEUED_FOR_WIFI;
669                 mInfo.notifyPauseDueToSize(true);
670             } else if (networkUsable == NetworkState.RECOMMENDED_UNUSABLE_DUE_TO_SIZE) {
671                 status = Downloads.Impl.STATUS_QUEUED_FOR_WIFI;
672                 mInfo.notifyPauseDueToSize(false);
673             }
674             throw new StopRequestException(status, networkUsable.name());
675         }
676     }
677
678     /**
679      * Check if the download has been paused or canceled, stopping the request
680      * appropriately if it has been.
681      */
682     private void checkPausedOrCanceled() throws StopRequestException {
683         synchronized (mInfo) {
684             if (mInfo.mControl == Downloads.Impl.CONTROL_PAUSED) {
685                 throw new StopRequestException(
686                         Downloads.Impl.STATUS_PAUSED_BY_APP, "download paused by owner");
687             }
688             if (mInfo.mStatus == Downloads.Impl.STATUS_CANCELED || mInfo.mDeleted) {
689                 throw new StopRequestException(Downloads.Impl.STATUS_CANCELED, "download canceled");
690             }
691         }
692
693         // if policy has been changed, trigger connectivity check
694         if (mPolicyDirty) {
695             checkConnectivity();
696         }
697     }
698
699     /**
700      * Report download progress through the database if necessary.
701      */
702     private void updateProgress(FileDescriptor outFd) throws IOException, StopRequestException {
703         final long now = SystemClock.elapsedRealtime();
704         final long currentBytes = mInfoDelta.mCurrentBytes;
705
706         final long sampleDelta = now - mSpeedSampleStart;
707         if (sampleDelta > 500) {
708             final long sampleSpeed = ((currentBytes - mSpeedSampleBytes) * 1000)
709                     / sampleDelta;
710
711             if (mSpeed == 0) {
712                 mSpeed = sampleSpeed;
713             } else {
714                 mSpeed = ((mSpeed * 3) + sampleSpeed) / 4;
715             }
716
717             // Only notify once we have a full sample window
718             if (mSpeedSampleStart != 0) {
719                 mNotifier.notifyDownloadSpeed(mId, mSpeed);
720             }
721
722             mSpeedSampleStart = now;
723             mSpeedSampleBytes = currentBytes;
724         }
725
726         final long bytesDelta = currentBytes - mLastUpdateBytes;
727         final long timeDelta = now - mLastUpdateTime;
728         if (bytesDelta > Constants.MIN_PROGRESS_STEP && timeDelta > Constants.MIN_PROGRESS_TIME) {
729             // fsync() to ensure that current progress has been flushed to disk,
730             // so we can always resume based on latest database information.
731             outFd.sync();
732
733             mInfoDelta.writeToDatabaseOrThrow();
734
735             mLastUpdateBytes = currentBytes;
736             mLastUpdateTime = now;
737         }
738     }
739
740     /**
741      * Process response headers from first server response. This derives its
742      * filename, size, and ETag.
743      */
744     private void parseOkHeaders(HttpURLConnection conn) throws StopRequestException {
745         if (mInfoDelta.mFileName == null) {
746             final String contentDisposition = conn.getHeaderField("Content-Disposition");
747             final String contentLocation = conn.getHeaderField("Content-Location");
748
749             try {
750                 mInfoDelta.mFileName = Helpers.generateSaveFile(mContext, mInfoDelta.mUri,
751                         mInfo.mHint, contentDisposition, contentLocation, mInfoDelta.mMimeType,
752                         mInfo.mDestination);
753             } catch (IOException e) {
754                 throw new StopRequestException(
755                         Downloads.Impl.STATUS_FILE_ERROR, "Failed to generate filename: " + e);
756             }
757         }
758
759         if (mInfoDelta.mMimeType == null) {
760             mInfoDelta.mMimeType = Intent.normalizeMimeType(conn.getContentType());
761         }
762
763         final String transferEncoding = conn.getHeaderField("Transfer-Encoding");
764         if (transferEncoding == null) {
765             mInfoDelta.mTotalBytes = getHeaderFieldLong(conn, "Content-Length", -1);
766         } else {
767             mInfoDelta.mTotalBytes = -1;
768         }
769
770         mInfoDelta.mETag = conn.getHeaderField("ETag");
771
772         mInfoDelta.writeToDatabaseOrThrow();
773
774         // Check connectivity again now that we know the total size
775         checkConnectivity();
776     }
777
778     private void parseUnavailableHeaders(HttpURLConnection conn) {
779         long retryAfter = conn.getHeaderFieldInt("Retry-After", -1);
780         if (retryAfter < 0) {
781             retryAfter = 0;
782         } else {
783             if (retryAfter < Constants.MIN_RETRY_AFTER) {
784                 retryAfter = Constants.MIN_RETRY_AFTER;
785             } else if (retryAfter > Constants.MAX_RETRY_AFTER) {
786                 retryAfter = Constants.MAX_RETRY_AFTER;
787             }
788             retryAfter += Helpers.sRandom.nextInt(Constants.MIN_RETRY_AFTER + 1);
789         }
790
791         mInfoDelta.mRetryAfter = (int) (retryAfter * SECOND_IN_MILLIS);
792     }
793
794     /**
795      * Add custom headers for this download to the HTTP request.
796      */
797     private void addRequestHeaders(HttpURLConnection conn, boolean resuming) {
798         for (Pair<String, String> header : mInfo.getHeaders()) {
799             conn.addRequestProperty(header.first, header.second);
800         }
801
802         // Only splice in user agent when not already defined
803         if (conn.getRequestProperty("User-Agent") == null) {
804             conn.addRequestProperty("User-Agent", mInfo.getUserAgent());
805         }
806
807         // Defeat transparent gzip compression, since it doesn't allow us to
808         // easily resume partial downloads.
809         conn.setRequestProperty("Accept-Encoding", "identity");
810
811         // Defeat connection reuse, since otherwise servers may continue
812         // streaming large downloads after cancelled.
813         conn.setRequestProperty("Connection", "close");
814
815         if (resuming) {
816             if (mInfoDelta.mETag != null) {
817                 conn.addRequestProperty("If-Match", mInfoDelta.mETag);
818             }
819             conn.addRequestProperty("Range", "bytes=" + mInfoDelta.mCurrentBytes + "-");
820         }
821     }
822
823     private void logDebug(String msg) {
824         Log.d(TAG, "[" + mId + "] " + msg);
825     }
826
827     private void logWarning(String msg) {
828         Log.w(TAG, "[" + mId + "] " + msg);
829     }
830
831     private void logError(String msg, Throwable t) {
832         Log.e(TAG, "[" + mId + "] " + msg, t);
833     }
834
835     private INetworkPolicyListener mPolicyListener = new INetworkPolicyListener.Stub() {
836         @Override
837         public void onUidRulesChanged(int uid, int uidRules) {
838             // caller is NPMS, since we only register with them
839             if (uid == mInfo.mUid) {
840                 mPolicyDirty = true;
841             }
842         }
843
844         @Override
845         public void onMeteredIfacesChanged(String[] meteredIfaces) {
846             // caller is NPMS, since we only register with them
847             mPolicyDirty = true;
848         }
849
850         @Override
851         public void onRestrictBackgroundChanged(boolean restrictBackground) {
852             // caller is NPMS, since we only register with them
853             mPolicyDirty = true;
854         }
855     };
856
857     private static long getHeaderFieldLong(URLConnection conn, String field, long defaultValue) {
858         try {
859             return Long.parseLong(conn.getHeaderField(field));
860         } catch (NumberFormatException e) {
861             return defaultValue;
862         }
863     }
864
865     /**
866      * Return if given status is eligible to be treated as
867      * {@link android.provider.Downloads.Impl#STATUS_WAITING_TO_RETRY}.
868      */
869     public static boolean isStatusRetryable(int status) {
870         switch (status) {
871             case STATUS_HTTP_DATA_ERROR:
872             case HTTP_UNAVAILABLE:
873             case HTTP_INTERNAL_ERROR:
874             case STATUS_FILE_ERROR:
875                 return true;
876             default:
877                 return false;
878         }
879     }
880 }