| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.providers.downloads; |
| |
| import static android.text.format.DateUtils.MINUTE_IN_MILLIS; |
| import static com.android.providers.downloads.Constants.TAG; |
| import static java.net.HttpURLConnection.HTTP_OK; |
| import static java.net.HttpURLConnection.HTTP_PARTIAL; |
| import static java.net.HttpURLConnection.HTTP_UNAVAILABLE; |
| |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.drm.DrmManagerClient; |
| import android.drm.DrmOutputStream; |
| import android.net.INetworkPolicyListener; |
| import android.net.NetworkPolicyManager; |
| import android.net.TrafficStats; |
| import android.os.FileUtils; |
| import android.os.PowerManager; |
| import android.os.Process; |
| import android.os.SystemClock; |
| import android.provider.Downloads; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.util.Pair; |
| |
| import java.io.File; |
| import java.io.FileDescriptor; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.RandomAccessFile; |
| import java.net.HttpURLConnection; |
| import java.net.URL; |
| import java.net.URLConnection; |
| |
| import libcore.io.IoUtils; |
| |
| /** |
| * Thread which executes a given {@link DownloadInfo}: making network requests, |
| * persisting data to disk, and updating {@link DownloadProvider}. |
| */ |
| public class DownloadThread extends Thread { |
| |
| private static final int HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416; |
| |
| private static final int DEFAULT_TIMEOUT = (int) MINUTE_IN_MILLIS; |
| |
| private final Context mContext; |
| private final DownloadInfo mInfo; |
| private final SystemFacade mSystemFacade; |
| private final StorageManager mStorageManager; |
| |
| private volatile boolean mPolicyDirty; |
| |
| public DownloadThread(Context context, SystemFacade systemFacade, DownloadInfo info, |
| StorageManager storageManager) { |
| mContext = context; |
| mSystemFacade = systemFacade; |
| mInfo = info; |
| mStorageManager = storageManager; |
| } |
| |
| /** |
| * Returns the user agent provided by the initiating app, or use the default one |
| */ |
| private String userAgent() { |
| String userAgent = mInfo.mUserAgent; |
| if (userAgent == null) { |
| userAgent = Constants.DEFAULT_USER_AGENT; |
| } |
| return userAgent; |
| } |
| |
| /** |
| * State for the entire run() method. |
| */ |
| static class State { |
| public String mFilename; |
| public String mMimeType; |
| public boolean mCountRetry = false; |
| public int mRetryAfter = 0; |
| public boolean mGotData = false; |
| public String mRequestUri; |
| public long mTotalBytes = -1; |
| public long mCurrentBytes = 0; |
| public String mHeaderETag; |
| public boolean mContinuingDownload = false; |
| public long mBytesNotified = 0; |
| public long mTimeLastNotification = 0; |
| |
| /** Historical bytes/second speed of this download. */ |
| public long mSpeed; |
| /** Time when current sample started. */ |
| public long mSpeedSampleStart; |
| /** Bytes transferred since current sample started. */ |
| public long mSpeedSampleBytes; |
| |
| public State(DownloadInfo info) { |
| mMimeType = Intent.normalizeMimeType(info.mMimeType); |
| mRequestUri = info.mUri; |
| mFilename = info.mFileName; |
| mTotalBytes = info.mTotalBytes; |
| mCurrentBytes = info.mCurrentBytes; |
| } |
| } |
| |
| /** |
| * State within executeDownload() |
| */ |
| private static class InnerState { |
| public long mContentLength; |
| public String mContentDisposition; |
| public String mContentLocation; |
| } |
| |
| /** |
| * Executes the download in a separate thread |
| */ |
| @Override |
| public void run() { |
| Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); |
| try { |
| runInternal(); |
| } finally { |
| DownloadHandler.getInstance().dequeueDownload(mInfo.mId); |
| } |
| } |
| |
| private void runInternal() { |
| // Skip when download already marked as finished; this download was |
| // probably started again while racing with UpdateThread. |
| if (DownloadInfo.queryDownloadStatus(mContext.getContentResolver(), mInfo.mId) |
| == Downloads.Impl.STATUS_SUCCESS) { |
| Log.d(TAG, "Download " + mInfo.mId + " already finished; skipping"); |
| return; |
| } |
| |
| State state = new State(mInfo); |
| PowerManager.WakeLock wakeLock = null; |
| int finalStatus = Downloads.Impl.STATUS_UNKNOWN_ERROR; |
| String errorMsg = null; |
| |
| final NetworkPolicyManager netPolicy = NetworkPolicyManager.from(mContext); |
| final PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); |
| |
| try { |
| wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, Constants.TAG); |
| wakeLock.acquire(); |
| |
| // while performing download, register for rules updates |
| netPolicy.registerListener(mPolicyListener); |
| |
| if (Constants.LOGV) { |
| Log.v(Constants.TAG, "initiating download for " + mInfo.mUri); |
| } |
| |
| // network traffic on this thread should be counted against the |
| // requesting uid, and is tagged with well-known value. |
| TrafficStats.setThreadStatsTag(TrafficStats.TAG_SYSTEM_DOWNLOAD); |
| TrafficStats.setThreadStatsUid(mInfo.mUid); |
| |
| boolean finished = false; |
| while (!finished) { |
| Log.i(Constants.TAG, "Initiating request for download " + mInfo.mId); |
| |
| final URL url = new URL(state.mRequestUri); |
| final HttpURLConnection conn = (HttpURLConnection) url.openConnection(); |
| conn.setConnectTimeout(DEFAULT_TIMEOUT); |
| conn.setReadTimeout(DEFAULT_TIMEOUT); |
| try { |
| executeDownload(state, conn); |
| finished = true; |
| } finally { |
| conn.disconnect(); |
| } |
| } |
| |
| if (Constants.LOGV) { |
| Log.v(Constants.TAG, "download completed for " + mInfo.mUri); |
| } |
| finalizeDestinationFile(state); |
| finalStatus = Downloads.Impl.STATUS_SUCCESS; |
| } catch (StopRequestException error) { |
| // remove the cause before printing, in case it contains PII |
| errorMsg = error.getMessage(); |
| String msg = "Aborting request for download " + mInfo.mId + ": " + errorMsg; |
| Log.w(Constants.TAG, msg); |
| if (Constants.LOGV) { |
| Log.w(Constants.TAG, msg, error); |
| } |
| finalStatus = error.mFinalStatus; |
| // fall through to finally block |
| } catch (Throwable ex) { |
| errorMsg = ex.getMessage(); |
| String msg = "Exception for id " + mInfo.mId + ": " + errorMsg; |
| Log.w(Constants.TAG, msg, ex); |
| finalStatus = Downloads.Impl.STATUS_UNKNOWN_ERROR; |
| // falls through to the code that reports an error |
| } finally { |
| TrafficStats.clearThreadStatsTag(); |
| TrafficStats.clearThreadStatsUid(); |
| |
| cleanupDestination(state, finalStatus); |
| notifyDownloadCompleted(finalStatus, state.mCountRetry, state.mRetryAfter, |
| state.mGotData, state.mFilename, state.mMimeType, errorMsg); |
| |
| netPolicy.unregisterListener(mPolicyListener); |
| |
| if (wakeLock != null) { |
| wakeLock.release(); |
| wakeLock = null; |
| } |
| } |
| mStorageManager.incrementNumDownloadsSoFar(); |
| } |
| |
| /** |
| * Fully execute a single download request - setup and send the request, handle the response, |
| * and transfer the data to the destination file. |
| */ |
| private void executeDownload(State state, HttpURLConnection conn) throws StopRequestException { |
| final InnerState innerState = new InnerState(); |
| |
| setupDestinationFile(state, innerState); |
| addRequestHeaders(state, conn); |
| |
| // skip when already finished; remove after fixing race in 5217390 |
| if (state.mCurrentBytes == state.mTotalBytes) { |
| Log.i(Constants.TAG, "Skipping initiating request for download " + |
| mInfo.mId + "; already completed"); |
| return; |
| } |
| |
| // check just before sending the request to avoid using an invalid connection at all |
| checkConnectivity(); |
| |
| DrmManagerClient drmClient = null; |
| InputStream in = null; |
| OutputStream out = null; |
| FileDescriptor outFd = null; |
| try { |
| try { |
| // Asking for response code will execute the request |
| final int statusCode = conn.getResponseCode(); |
| in = conn.getInputStream(); |
| |
| handleExceptionalStatus(state, innerState, conn, statusCode); |
| processResponseHeaders(state, innerState, conn); |
| } catch (IOException e) { |
| throw new StopRequestException( |
| getFinalStatusForHttpError(state), "Request failed: " + e, e); |
| } |
| |
| try { |
| if (DownloadDrmHelper.isDrmConvertNeeded(state.mMimeType)) { |
| drmClient = new DrmManagerClient(mContext); |
| final RandomAccessFile file = new RandomAccessFile( |
| new File(state.mFilename), "rw"); |
| out = new DrmOutputStream(drmClient, file, state.mMimeType); |
| outFd = file.getFD(); |
| } else { |
| out = new FileOutputStream(state.mFilename, true); |
| outFd = ((FileOutputStream) out).getFD(); |
| } |
| } catch (IOException e) { |
| throw new StopRequestException( |
| Downloads.Impl.STATUS_FILE_ERROR, "Failed to open destination: " + e, e); |
| } |
| |
| transferData(state, innerState, in, out); |
| |
| try { |
| if (out instanceof DrmOutputStream) { |
| ((DrmOutputStream) out).finish(); |
| } |
| } catch (IOException e) { |
| throw new StopRequestException( |
| Downloads.Impl.STATUS_FILE_ERROR, "Failed to finish: " + e, e); |
| } |
| |
| } finally { |
| if (drmClient != null) { |
| drmClient.release(); |
| } |
| |
| IoUtils.closeQuietly(in); |
| |
| try { |
| if (out != null) out.flush(); |
| if (outFd != null) outFd.sync(); |
| } catch (IOException e) { |
| } finally { |
| IoUtils.closeQuietly(out); |
| } |
| } |
| } |
| |
| /** |
| * Check if current connectivity is valid for this request. |
| */ |
| private void checkConnectivity() throws StopRequestException { |
| // checking connectivity will apply current policy |
| mPolicyDirty = false; |
| |
| int networkUsable = mInfo.checkCanUseNetwork(); |
| if (networkUsable != DownloadInfo.NETWORK_OK) { |
| int status = Downloads.Impl.STATUS_WAITING_FOR_NETWORK; |
| if (networkUsable == DownloadInfo.NETWORK_UNUSABLE_DUE_TO_SIZE) { |
| status = Downloads.Impl.STATUS_QUEUED_FOR_WIFI; |
| mInfo.notifyPauseDueToSize(true); |
| } else if (networkUsable == DownloadInfo.NETWORK_RECOMMENDED_UNUSABLE_DUE_TO_SIZE) { |
| status = Downloads.Impl.STATUS_QUEUED_FOR_WIFI; |
| mInfo.notifyPauseDueToSize(false); |
| } |
| throw new StopRequestException(status, |
| mInfo.getLogMessageForNetworkError(networkUsable)); |
| } |
| } |
| |
| /** |
| * Transfer as much data as possible from the HTTP response to the |
| * destination file. |
| */ |
| private void transferData(State state, InnerState innerState, InputStream in, OutputStream out) |
| throws StopRequestException { |
| final byte data[] = new byte[Constants.BUFFER_SIZE]; |
| for (;;) { |
| int bytesRead = readFromResponse(state, innerState, data, in); |
| if (bytesRead == -1) { // success, end of stream already reached |
| handleEndOfStream(state, innerState); |
| return; |
| } |
| |
| state.mGotData = true; |
| writeDataToDestination(state, data, bytesRead, out); |
| state.mCurrentBytes += bytesRead; |
| reportProgress(state, innerState); |
| |
| if (Constants.LOGVV) { |
| Log.v(Constants.TAG, "downloaded " + state.mCurrentBytes + " for " |
| + mInfo.mUri); |
| } |
| |
| checkPausedOrCanceled(state); |
| } |
| } |
| |
| /** |
| * Called after a successful completion to take any necessary action on the downloaded file. |
| */ |
| private void finalizeDestinationFile(State state) { |
| if (state.mFilename != null) { |
| // make sure the file is readable |
| FileUtils.setPermissions(state.mFilename, 0644, -1, -1); |
| } |
| } |
| |
| /** |
| * Called just before the thread finishes, regardless of status, to take any necessary action on |
| * the downloaded file. |
| */ |
| private void cleanupDestination(State state, int finalStatus) { |
| if (state.mFilename != null && Downloads.Impl.isStatusError(finalStatus)) { |
| if (Constants.LOGVV) { |
| Log.d(TAG, "cleanupDestination() deleting " + state.mFilename); |
| } |
| new File(state.mFilename).delete(); |
| state.mFilename = null; |
| } |
| } |
| |
| /** |
| * Check if the download has been paused or canceled, stopping the request appropriately if it |
| * has been. |
| */ |
| private void checkPausedOrCanceled(State state) throws StopRequestException { |
| synchronized (mInfo) { |
| if (mInfo.mControl == Downloads.Impl.CONTROL_PAUSED) { |
| throw new StopRequestException( |
| Downloads.Impl.STATUS_PAUSED_BY_APP, "download paused by owner"); |
| } |
| if (mInfo.mStatus == Downloads.Impl.STATUS_CANCELED) { |
| throw new StopRequestException(Downloads.Impl.STATUS_CANCELED, "download canceled"); |
| } |
| } |
| |
| // if policy has been changed, trigger connectivity check |
| if (mPolicyDirty) { |
| checkConnectivity(); |
| } |
| } |
| |
| /** |
| * Report download progress through the database if necessary. |
| */ |
| private void reportProgress(State state, InnerState innerState) { |
| final long now = SystemClock.elapsedRealtime(); |
| |
| final long sampleDelta = now - state.mSpeedSampleStart; |
| if (sampleDelta > 500) { |
| final long sampleSpeed = ((state.mCurrentBytes - state.mSpeedSampleBytes) * 1000) |
| / sampleDelta; |
| |
| if (state.mSpeed == 0) { |
| state.mSpeed = sampleSpeed; |
| } else { |
| state.mSpeed = ((state.mSpeed * 3) + sampleSpeed) / 4; |
| } |
| |
| state.mSpeedSampleStart = now; |
| state.mSpeedSampleBytes = state.mCurrentBytes; |
| |
| DownloadHandler.getInstance().setCurrentSpeed(mInfo.mId, state.mSpeed); |
| } |
| |
| if (state.mCurrentBytes - state.mBytesNotified > Constants.MIN_PROGRESS_STEP && |
| now - state.mTimeLastNotification > Constants.MIN_PROGRESS_TIME) { |
| ContentValues values = new ContentValues(); |
| values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, state.mCurrentBytes); |
| mContext.getContentResolver().update(mInfo.getAllDownloadsUri(), values, null, null); |
| state.mBytesNotified = state.mCurrentBytes; |
| state.mTimeLastNotification = now; |
| } |
| } |
| |
| /** |
| * Write a data buffer to the destination file. |
| * @param data buffer containing the data to write |
| * @param bytesRead how many bytes to write from the buffer |
| */ |
| private void writeDataToDestination(State state, byte[] data, int bytesRead, OutputStream out) |
| throws StopRequestException { |
| mStorageManager.verifySpaceBeforeWritingToFile( |
| mInfo.mDestination, state.mFilename, bytesRead); |
| |
| boolean forceVerified = false; |
| while (true) { |
| try { |
| out.write(data, 0, bytesRead); |
| return; |
| } catch (IOException ex) { |
| // TODO: better differentiate between DRM and disk failures |
| if (!forceVerified) { |
| // couldn't write to file. are we out of space? check. |
| mStorageManager.verifySpace(mInfo.mDestination, state.mFilename, bytesRead); |
| forceVerified = true; |
| } else { |
| throw new StopRequestException(Downloads.Impl.STATUS_FILE_ERROR, |
| "Failed to write data: " + ex); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Called when we've reached the end of the HTTP response stream, to update the database and |
| * check for consistency. |
| */ |
| private void handleEndOfStream(State state, InnerState innerState) throws StopRequestException { |
| ContentValues values = new ContentValues(); |
| values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, state.mCurrentBytes); |
| if (innerState.mContentLength == -1) { |
| values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, state.mCurrentBytes); |
| } |
| mContext.getContentResolver().update(mInfo.getAllDownloadsUri(), values, null, null); |
| |
| boolean lengthMismatched = (innerState.mContentLength != -1) |
| && (state.mCurrentBytes != innerState.mContentLength); |
| if (lengthMismatched) { |
| if (cannotResume(state)) { |
| throw new StopRequestException(Downloads.Impl.STATUS_CANNOT_RESUME, |
| "mismatched content length; unable to resume"); |
| } else { |
| throw new StopRequestException(getFinalStatusForHttpError(state), |
| "closed socket before end of file"); |
| } |
| } |
| } |
| |
| private boolean cannotResume(State state) { |
| return (state.mCurrentBytes > 0 && !mInfo.mNoIntegrity && state.mHeaderETag == null) |
| || DownloadDrmHelper.isDrmConvertNeeded(state.mMimeType); |
| } |
| |
| /** |
| * Read some data from the HTTP response stream, handling I/O errors. |
| * @param data buffer to use to read data |
| * @param entityStream stream for reading the HTTP response entity |
| * @return the number of bytes actually read or -1 if the end of the stream has been reached |
| */ |
| private int readFromResponse(State state, InnerState innerState, byte[] data, |
| InputStream entityStream) throws StopRequestException { |
| try { |
| return entityStream.read(data); |
| } catch (IOException ex) { |
| // TODO: handle stream errors the same as other retries |
| if ("unexpected end of stream".equals(ex.getMessage())) { |
| return -1; |
| } |
| |
| ContentValues values = new ContentValues(); |
| values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, state.mCurrentBytes); |
| mContext.getContentResolver().update(mInfo.getAllDownloadsUri(), values, null, null); |
| if (cannotResume(state)) { |
| throw new StopRequestException(Downloads.Impl.STATUS_CANNOT_RESUME, |
| "Failed reading response: " + ex + "; unable to resume", ex); |
| } else { |
| throw new StopRequestException(getFinalStatusForHttpError(state), |
| "Failed reading response: " + ex, ex); |
| } |
| } |
| } |
| |
| /** |
| * Read HTTP response headers and take appropriate action, including setting up the destination |
| * file and updating the database. |
| */ |
| private void processResponseHeaders(State state, InnerState innerState, HttpURLConnection conn) |
| throws StopRequestException { |
| if (state.mContinuingDownload) { |
| // ignore response headers on resume requests |
| return; |
| } |
| |
| readResponseHeaders(state, innerState, conn); |
| |
| state.mFilename = Helpers.generateSaveFile( |
| mContext, |
| mInfo.mUri, |
| mInfo.mHint, |
| innerState.mContentDisposition, |
| innerState.mContentLocation, |
| state.mMimeType, |
| mInfo.mDestination, |
| innerState.mContentLength, |
| mInfo.mIsPublicApi, mStorageManager); |
| |
| updateDatabaseFromHeaders(state, innerState); |
| // check connectivity again now that we know the total size |
| checkConnectivity(); |
| } |
| |
| /** |
| * Update necessary database fields based on values of HTTP response headers that have been |
| * read. |
| */ |
| private void updateDatabaseFromHeaders(State state, InnerState innerState) { |
| ContentValues values = new ContentValues(); |
| values.put(Downloads.Impl._DATA, state.mFilename); |
| if (state.mHeaderETag != null) { |
| values.put(Constants.ETAG, state.mHeaderETag); |
| } |
| if (state.mMimeType != null) { |
| values.put(Downloads.Impl.COLUMN_MIME_TYPE, state.mMimeType); |
| } |
| values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, mInfo.mTotalBytes); |
| mContext.getContentResolver().update(mInfo.getAllDownloadsUri(), values, null, null); |
| } |
| |
| /** |
| * Read headers from the HTTP response and store them into local state. |
| */ |
| private void readResponseHeaders(State state, InnerState innerState, HttpURLConnection conn) |
| throws StopRequestException { |
| innerState.mContentDisposition = conn.getHeaderField("Content-Disposition"); |
| innerState.mContentLocation = conn.getHeaderField("Content-Location"); |
| |
| if (state.mMimeType == null) { |
| state.mMimeType = Intent.normalizeMimeType(conn.getContentType()); |
| } |
| |
| state.mHeaderETag = conn.getHeaderField("ETag"); |
| |
| final String transferEncoding = conn.getHeaderField("Transfer-Encoding"); |
| if (transferEncoding == null) { |
| innerState.mContentLength = getHeaderFieldLong(conn, "Content-Length", -1); |
| } else { |
| Log.i(TAG, "Ignoring Content-Length since Transfer-Encoding is also defined"); |
| innerState.mContentLength = -1; |
| } |
| |
| state.mTotalBytes = innerState.mContentLength; |
| mInfo.mTotalBytes = innerState.mContentLength; |
| |
| final boolean noSizeInfo = innerState.mContentLength == -1 |
| && (transferEncoding == null || !transferEncoding.equalsIgnoreCase("chunked")); |
| if (!mInfo.mNoIntegrity && noSizeInfo) { |
| throw new StopRequestException(Downloads.Impl.STATUS_HTTP_DATA_ERROR, |
| "can't know size of download, giving up"); |
| } |
| } |
| |
| /** |
| * Check the HTTP response status and handle anything unusual (e.g. not 200/206). |
| */ |
| private void handleExceptionalStatus( |
| State state, InnerState innerState, HttpURLConnection conn, int statusCode) |
| throws StopRequestException { |
| if (statusCode == HTTP_UNAVAILABLE && mInfo.mNumFailed < Constants.MAX_RETRIES) { |
| handleServiceUnavailable(state, conn); |
| } |
| |
| if (Constants.LOGV) { |
| Log.i(Constants.TAG, "recevd_status = " + statusCode + |
| ", mContinuingDownload = " + state.mContinuingDownload); |
| } |
| int expectedStatus = state.mContinuingDownload ? HTTP_PARTIAL : HTTP_OK; |
| if (statusCode != expectedStatus) { |
| handleOtherStatus(state, innerState, statusCode); |
| } |
| } |
| |
| /** |
| * Handle a status that we don't know how to deal with properly. |
| */ |
| private void handleOtherStatus(State state, InnerState innerState, int statusCode) |
| throws StopRequestException { |
| if (statusCode == HTTP_REQUESTED_RANGE_NOT_SATISFIABLE) { |
| // range request failed. it should never fail. |
| throw new IllegalStateException("Http Range request failure: totalBytes = " + |
| state.mTotalBytes + ", bytes recvd so far: " + state.mCurrentBytes); |
| } |
| int finalStatus; |
| if (statusCode >= 400 && statusCode < 600) { |
| finalStatus = statusCode; |
| } else if (statusCode >= 300 && statusCode < 400) { |
| finalStatus = Downloads.Impl.STATUS_UNHANDLED_REDIRECT; |
| } else if (state.mContinuingDownload && statusCode == HTTP_OK) { |
| finalStatus = Downloads.Impl.STATUS_CANNOT_RESUME; |
| } else { |
| finalStatus = Downloads.Impl.STATUS_UNHANDLED_HTTP_CODE; |
| } |
| throw new StopRequestException(finalStatus, "http error " + |
| statusCode + ", mContinuingDownload: " + state.mContinuingDownload); |
| } |
| |
| /** |
| * Handle a 503 Service Unavailable status by processing the Retry-After header. |
| */ |
| private void handleServiceUnavailable(State state, HttpURLConnection conn) |
| throws StopRequestException { |
| state.mCountRetry = true; |
| state.mRetryAfter = conn.getHeaderFieldInt("Retry-After", -1); |
| if (state.mRetryAfter < 0) { |
| state.mRetryAfter = 0; |
| } else { |
| if (state.mRetryAfter < Constants.MIN_RETRY_AFTER) { |
| state.mRetryAfter = Constants.MIN_RETRY_AFTER; |
| } else if (state.mRetryAfter > Constants.MAX_RETRY_AFTER) { |
| state.mRetryAfter = Constants.MAX_RETRY_AFTER; |
| } |
| state.mRetryAfter += Helpers.sRandom.nextInt(Constants.MIN_RETRY_AFTER + 1); |
| state.mRetryAfter *= 1000; |
| } |
| |
| throw new StopRequestException(Downloads.Impl.STATUS_WAITING_TO_RETRY, |
| "got 503 Service Unavailable, will retry later"); |
| } |
| |
| private int getFinalStatusForHttpError(State state) { |
| int networkUsable = mInfo.checkCanUseNetwork(); |
| if (networkUsable != DownloadInfo.NETWORK_OK) { |
| switch (networkUsable) { |
| case DownloadInfo.NETWORK_UNUSABLE_DUE_TO_SIZE: |
| case DownloadInfo.NETWORK_RECOMMENDED_UNUSABLE_DUE_TO_SIZE: |
| return Downloads.Impl.STATUS_QUEUED_FOR_WIFI; |
| default: |
| return Downloads.Impl.STATUS_WAITING_FOR_NETWORK; |
| } |
| } else if (mInfo.mNumFailed < Constants.MAX_RETRIES) { |
| state.mCountRetry = true; |
| return Downloads.Impl.STATUS_WAITING_TO_RETRY; |
| } else { |
| Log.w(Constants.TAG, "reached max retries for " + mInfo.mId); |
| return Downloads.Impl.STATUS_HTTP_DATA_ERROR; |
| } |
| } |
| |
| /** |
| * Prepare the destination file to receive data. If the file already exists, we'll set up |
| * appropriately for resumption. |
| */ |
| private void setupDestinationFile(State state, InnerState innerState) |
| throws StopRequestException { |
| if (!TextUtils.isEmpty(state.mFilename)) { // only true if we've already run a thread for this download |
| if (Constants.LOGV) { |
| Log.i(Constants.TAG, "have run thread before for id: " + mInfo.mId + |
| ", and state.mFilename: " + state.mFilename); |
| } |
| if (!Helpers.isFilenameValid(state.mFilename, |
| mStorageManager.getDownloadDataDirectory())) { |
| // this should never happen |
| throw new StopRequestException(Downloads.Impl.STATUS_FILE_ERROR, |
| "found invalid internal destination filename"); |
| } |
| // We're resuming a download that got interrupted |
| File f = new File(state.mFilename); |
| if (f.exists()) { |
| if (Constants.LOGV) { |
| Log.i(Constants.TAG, "resuming download for id: " + mInfo.mId + |
| ", and state.mFilename: " + state.mFilename); |
| } |
| long fileLength = f.length(); |
| if (fileLength == 0) { |
| // The download hadn't actually started, we can restart from scratch |
| if (Constants.LOGVV) { |
| Log.d(TAG, "setupDestinationFile() found fileLength=0, deleting " |
| + state.mFilename); |
| } |
| f.delete(); |
| state.mFilename = null; |
| if (Constants.LOGV) { |
| Log.i(Constants.TAG, "resuming download for id: " + mInfo.mId + |
| ", BUT starting from scratch again: "); |
| } |
| } else if (mInfo.mETag == null && !mInfo.mNoIntegrity) { |
| // This should've been caught upon failure |
| if (Constants.LOGVV) { |
| Log.d(TAG, "setupDestinationFile() unable to resume download, deleting " |
| + state.mFilename); |
| } |
| f.delete(); |
| throw new StopRequestException(Downloads.Impl.STATUS_CANNOT_RESUME, |
| "Trying to resume a download that can't be resumed"); |
| } else { |
| // All right, we'll be able to resume this download |
| if (Constants.LOGV) { |
| Log.i(Constants.TAG, "resuming download for id: " + mInfo.mId + |
| ", and starting with file of length: " + fileLength); |
| } |
| state.mCurrentBytes = (int) fileLength; |
| if (mInfo.mTotalBytes != -1) { |
| innerState.mContentLength = mInfo.mTotalBytes; |
| } |
| state.mHeaderETag = mInfo.mETag; |
| state.mContinuingDownload = true; |
| if (Constants.LOGV) { |
| Log.i(Constants.TAG, "resuming download for id: " + mInfo.mId + |
| ", state.mCurrentBytes: " + state.mCurrentBytes + |
| ", and setting mContinuingDownload to true: "); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Add custom headers for this download to the HTTP request. |
| */ |
| private void addRequestHeaders(State state, HttpURLConnection conn) { |
| conn.addRequestProperty("User-Agent", userAgent()); |
| |
| for (Pair<String, String> header : mInfo.getHeaders()) { |
| conn.addRequestProperty(header.first, header.second); |
| } |
| |
| if (state.mContinuingDownload) { |
| if (state.mHeaderETag != null) { |
| conn.addRequestProperty("If-Match", state.mHeaderETag); |
| } |
| conn.addRequestProperty("Range", "bytes=" + state.mCurrentBytes + "-"); |
| if (Constants.LOGV) { |
| Log.i(Constants.TAG, "Adding Range header: " + |
| "bytes=" + state.mCurrentBytes + "-"); |
| Log.i(Constants.TAG, " totalBytes = " + state.mTotalBytes); |
| } |
| } |
| } |
| |
| /** |
| * Stores information about the completed download, and notifies the initiating application. |
| */ |
| private void notifyDownloadCompleted(int status, boolean countRetry, int retryAfter, |
| boolean gotData, String filename, String mimeType, String errorMsg) { |
| notifyThroughDatabase( |
| status, countRetry, retryAfter, gotData, filename, mimeType, errorMsg); |
| if (Downloads.Impl.isStatusCompleted(status)) { |
| mInfo.sendIntentIfRequested(); |
| } |
| } |
| |
| private void notifyThroughDatabase(int status, boolean countRetry, int retryAfter, |
| boolean gotData, String filename, String mimeType, String errorMsg) { |
| ContentValues values = new ContentValues(); |
| values.put(Downloads.Impl.COLUMN_STATUS, status); |
| values.put(Downloads.Impl._DATA, filename); |
| values.put(Downloads.Impl.COLUMN_MIME_TYPE, mimeType); |
| values.put(Downloads.Impl.COLUMN_LAST_MODIFICATION, mSystemFacade.currentTimeMillis()); |
| values.put(Constants.RETRY_AFTER_X_REDIRECT_COUNT, retryAfter); |
| if (!countRetry) { |
| values.put(Constants.FAILED_CONNECTIONS, 0); |
| } else if (gotData) { |
| values.put(Constants.FAILED_CONNECTIONS, 1); |
| } else { |
| values.put(Constants.FAILED_CONNECTIONS, mInfo.mNumFailed + 1); |
| } |
| // save the error message. could be useful to developers. |
| if (!TextUtils.isEmpty(errorMsg)) { |
| values.put(Downloads.Impl.COLUMN_ERROR_MSG, errorMsg); |
| } |
| mContext.getContentResolver().update(mInfo.getAllDownloadsUri(), values, null, null); |
| } |
| |
| private INetworkPolicyListener mPolicyListener = new INetworkPolicyListener.Stub() { |
| @Override |
| public void onUidRulesChanged(int uid, int uidRules) { |
| // caller is NPMS, since we only register with them |
| if (uid == mInfo.mUid) { |
| mPolicyDirty = true; |
| } |
| } |
| |
| @Override |
| public void onMeteredIfacesChanged(String[] meteredIfaces) { |
| // caller is NPMS, since we only register with them |
| mPolicyDirty = true; |
| } |
| |
| @Override |
| public void onRestrictBackgroundChanged(boolean restrictBackground) { |
| // caller is NPMS, since we only register with them |
| mPolicyDirty = true; |
| } |
| }; |
| |
| public static long getHeaderFieldLong(URLConnection conn, String field, long defaultValue) { |
| try { |
| return Long.parseLong(conn.getHeaderField(field)); |
| } catch (NumberFormatException e) { |
| return defaultValue; |
| } |
| } |
| } |
