/*
|
* Copyright (C) 2010 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.mozillaonline.providers;
|
|
import java.io.File;
|
import java.io.FileNotFoundException;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Set;
|
|
import android.content.ContentResolver;
|
import android.content.ContentUris;
|
import android.content.ContentValues;
|
import android.content.Context;
|
import android.database.Cursor;
|
import android.database.CursorWrapper;
|
import android.net.ConnectivityManager;
|
import android.net.Uri;
|
import android.os.Environment;
|
import android.os.ParcelFileDescriptor;
|
import android.provider.BaseColumns;
|
import android.util.Log;
|
import android.util.Pair;
|
|
import com.mozillaonline.providers.downloads.Downloads;
|
|
/**
|
* The download manager is a system service that handles long-running HTTP
|
* downloads. Clients may request that a URI be downloaded to a particular
|
* destination file. The download manager will conduct the download in the
|
* background, taking care of HTTP interactions and retrying downloads after
|
* failures or across connectivity changes and system reboots.
|
*
|
* Instances of this class should be obtained through
|
* {@link android.content.Context#getSystemService(String)} by passing
|
* {@link android.content.Context#DOWNLOAD_SERVICE}.
|
*
|
* Apps that request downloads through this API should register a broadcast
|
* receiver for {@link #ACTION_NOTIFICATION_CLICKED} to appropriately handle
|
* when the user clicks on a running download in a notification or from the
|
* downloads UI.
|
*/
|
public class DownloadManager {
|
// 姝ｅ父鐨勬枃浠剁被鍨�
|
public final static int FILE_TYPE_NORMAL = 1;
|
// M3U8 video
|
public final static int FILE_TYPE_VIDEO_M3U8 = 2;
|
|
@SuppressWarnings("unused")
|
private static final String TAG = "DownloadManager";
|
|
/**
|
* An identifier for a particular download, unique across the system.
|
* Clients use this ID to make subsequent calls related to the download.
|
*/
|
public final static String COLUMN_ID = BaseColumns._ID;
|
|
/**
|
* The client-supplied title for this download. This will be displayed in
|
* system notifications. Defaults to the empty string.
|
*/
|
public final static String COLUMN_TITLE = "title";
|
|
/**
|
* The client-supplied description of this download. This will be displayed
|
* in system notifications. Defaults to the empty string.
|
*/
|
public final static String COLUMN_DESCRIPTION = "description";
|
|
/**
|
* URI to be downloaded.
|
*/
|
public final static String COLUMN_URI = "uri";
|
|
/**
|
* Internet Media Type of the downloaded file. If no value is provided upon
|
* creation, this will initially be null and will be filled in based on the
|
* server's response once the download has started.
|
*
|
* @see <a href="http://www.ietf.org/rfc/rfc1590.txt">RFC 1590, defining
|
* Media Types</a>
|
*/
|
public final static String COLUMN_MEDIA_TYPE = "media_type";
|
|
/**
|
* Total size of the download in bytes. This will initially be -1 and will
|
* be filled in once the download starts.
|
*/
|
public final static String COLUMN_TOTAL_SIZE_BYTES = "total_size";
|
|
/**
|
* Uri where downloaded file will be stored. If a destination is supplied by
|
* client, that URI will be used here. Otherwise, the value will initially
|
* be null and will be filled in with a generated URI once the download has
|
* started.
|
*/
|
public final static String COLUMN_LOCAL_URI = "local_uri";
|
|
/**
|
* Current status of the download, as one of the STATUS_* constants.
|
*/
|
public final static String COLUMN_STATUS = "status";
|
|
/**
|
* 排序字段
|
*/
|
|
public final static String COLUMN_ORDERBYID = "orderbyid";
|
|
/**
|
* Provides more detail on the status of the download. Its meaning depends
|
* on the value of {@link #COLUMN_STATUS}.
|
*
|
* When {@link #COLUMN_STATUS} is {@link #STATUS_FAILED}, this indicates the
|
* type of error that occurred. If an HTTP error occurred, this will hold
|
* the HTTP status code as defined in RFC 2616. Otherwise, it will hold one
|
* of the ERROR_* constants.
|
*
|
* When {@link #COLUMN_STATUS} is {@link #STATUS_PAUSED}, this indicates why
|
* the download is paused. It will hold one of the PAUSED_* constants.
|
*
|
* If {@link #COLUMN_STATUS} is neither {@link #STATUS_FAILED} nor
|
* {@link #STATUS_PAUSED}, this column's value is undefined.
|
*
|
* @see <a
|
* href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1.1">RFC
|
* 2616 status codes</a>
|
*/
|
public final static String COLUMN_REASON = "reason";
|
|
/**
|
* Number of bytes download so far. 下载字节数为止
|
*/
|
public final static String COLUMN_BYTES_DOWNLOADED_SO_FAR = "bytes_so_far";
|
|
/**
|
* Timestamp when the download was last modified, in下一次下载的时间戳
|
* {@link System#currentTimeMillis System.currentTimeMillis()} (wall clock
|
* time in UTC).
|
*/
|
public final static String COLUMN_LAST_MODIFIED_TIMESTAMP = "last_modified_timestamp";
|
|
/**
|
* Value of {@link #COLUMN_STATUS} when the download is waiting to start.
|
* 获得列状态的值当下载等待开始
|
*/
|
public final static int STATUS_PENDING = 1 << 0;
|
|
/**
|
* Value of {@link #COLUMN_STATUS} when the download is currently running.
|
* 获得下载的当前状态当列状态的值
|
*/
|
public final static int STATUS_RUNNING = 1 << 1;
|
|
/**
|
* Value of {@link #COLUMN_STATUS} when the download is waiting to retry or
|
* resume.等待下载重启或则继续
|
*/
|
public final static int STATUS_PAUSED = 1 << 2;
|
|
/**
|
* Value of {@link #COLUMN_STATUS} when the download has successfully
|
* completed.下载已经成功完成
|
*/
|
public final static int STATUS_SUCCESSFUL = 1 << 3;
|
|
/**
|
* Value of {@link #COLUMN_STATUS} when the download has failed (and will
|
* not be retried).下载失败(和不再重启)
|
*/
|
public final static int STATUS_FAILED = 1 << 4;
|
|
/**
|
* Value of COLUMN_ERROR_CODE when the download has completed with an error
|
* that doesn't fit under any other error code.
|
*
|
*/
|
public final static int ERROR_UNKNOWN = 1000;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when a storage issue arises which doesn't
|
* fit under any other error code. Use the more specific
|
* {@link #ERROR_INSUFFICIENT_SPACE} and {@link #ERROR_DEVICE_NOT_FOUND}
|
* when appropriate.
|
*/
|
public final static int ERROR_FILE_ERROR = 1001;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when an HTTP code was received that
|
* download manager can't handle.
|
*/
|
public final static int ERROR_UNHANDLED_HTTP_CODE = 1002;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when an error receiving or processing
|
* data occurred at the HTTP level.
|
*/
|
public final static int ERROR_HTTP_DATA_ERROR = 1004;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when there were too many redirects.
|
*/
|
public final static int ERROR_TOO_MANY_REDIRECTS = 1005;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when there was insufficient storage
|
* space. Typically, this is because the SD card is full.
|
*/
|
public final static int ERROR_INSUFFICIENT_SPACE = 1006;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when no external storage device was
|
* found. Typically, this is because the SD card is not mounted.
|
*/
|
public final static int ERROR_DEVICE_NOT_FOUND = 1007;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when some possibly transient error
|
* occurred but we can't resume the download.
|
*/
|
public final static int ERROR_CANNOT_RESUME = 1008;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when the requested destination file
|
* already exists (the download manager will not overwrite an existing
|
* file).
|
*/
|
public final static int ERROR_FILE_ALREADY_EXISTS = 1009;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when the download is paused because some
|
* network error occurred and the download manager is waiting before
|
* retrying the request.
|
*/
|
public final static int PAUSED_WAITING_TO_RETRY = 1;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when the download is waiting for network
|
* connectivity to proceed.
|
*/
|
public final static int PAUSED_WAITING_FOR_NETWORK = 2;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when the download exceeds a size limit
|
* for downloads over the mobile network and the download manager is waiting
|
* for a Wi-Fi connection to proceed.
|
*/
|
public final static int PAUSED_QUEUED_FOR_WIFI = 3;
|
|
/**
|
* Value of {@link #COLUMN_REASON} when the download is paused for some
|
* other reason.
|
*/
|
public final static int PAUSED_UNKNOWN = 4;
|
|
/**
|
* Broadcast intent action sent by the download manager when a download
|
* completes.
|
*/
|
public final static String ACTION_DOWNLOAD_COMPLETE = "android.intent.action.DOWNLOAD_COMPLETE";
|
|
/**
|
* Broadcast intent action sent by the download manager when the user clicks
|
* on a running download, either from a system notification or from the
|
* downloads UI.
|
*/
|
public final static String ACTION_NOTIFICATION_CLICKED = "android.intent.action.DOWNLOAD_NOTIFICATION_CLICKED";
|
|
/**
|
* Intent action to launch an activity to display all downloads.
|
*/
|
public final static String ACTION_VIEW_DOWNLOADS = "android.intent.action.VIEW_DOWNLOADS";
|
|
/**
|
* Intent extra included with {@link #ACTION_DOWNLOAD_COMPLETE} intents,
|
* indicating the ID (as a long) of the download that just completed.
|
*/
|
public static final String EXTRA_DOWNLOAD_ID = "extra_download_id";
|
|
// this array must contain all public columns
|
private static final String[] COLUMNS = new String[] { COLUMN_ID,
|
COLUMN_TITLE, COLUMN_DESCRIPTION, COLUMN_URI, COLUMN_MEDIA_TYPE,
|
COLUMN_TOTAL_SIZE_BYTES, COLUMN_LOCAL_URI, COLUMN_STATUS,
|
COLUMN_REASON, COLUMN_BYTES_DOWNLOADED_SO_FAR,
|
COLUMN_LAST_MODIFIED_TIMESTAMP };
|
|
// columns to request from DownloadProvider
|
private static final String[] UNDERLYING_COLUMNS = new String[] {
|
Downloads._ID, Downloads.COLUMN_TITLE,
|
Downloads.COLUMN_DESCRIPTION, Downloads.COLUMN_URI,
|
Downloads.COLUMN_MIME_TYPE, Downloads.COLUMN_TOTAL_BYTES,
|
Downloads.COLUMN_STATUS, Downloads.COLUMN_CURRENT_BYTES,
|
Downloads.COLUMN_LAST_MODIFICATION, Downloads.COLUMN_DESTINATION,
|
Downloads.COLUMN_FILE_NAME_HINT, Downloads._DATA, };
|
|
private static final Set<String> LONG_COLUMNS = new HashSet<String>(
|
Arrays.asList(COLUMN_ID, COLUMN_TOTAL_SIZE_BYTES, COLUMN_STATUS,
|
COLUMN_REASON, COLUMN_BYTES_DOWNLOADED_SO_FAR,
|
COLUMN_LAST_MODIFIED_TIMESTAMP));
|
|
/**
|
* This class contains all the information necessary to request a new
|
* download. The URI is the only required parameter.
|
*
|
* Note that the default download destination is a shared volume where the
|
* system might delete your file if it needs to reclaim space for system
|
* use. If this is a problem, use a location on external storage (see
|
* {@link #setDestinationUri(Uri)}.
|
*/
|
public static class Request {
|
/**
|
* Bit flag for {@link #setAllowedNetworkTypes} corresponding to
|
* {@link ConnectivityManager#TYPE_MOBILE}.
|
*/
|
public static final int NETWORK_MOBILE = 1 << 0;
|
|
/**
|
* Bit flag for {@link #setAllowedNetworkTypes} corresponding to
|
* {@link ConnectivityManager#TYPE_WIFI}.
|
*/
|
public static final int NETWORK_WIFI = 1 << 1;
|
|
private Uri mUri;
|
private Uri mDestinationUri;
|
private List<Pair<String, String>> mRequestHeaders = new ArrayList<Pair<String, String>>();
|
private CharSequence mTitle;
|
private CharSequence mDescription;
|
private boolean mShowNotification = true;
|
private String mMimeType;
|
private boolean mRoamingAllowed = true;
|
private int mAllowedNetworkTypes = ~0; // default to all network types
|
// allowed
|
private boolean mIsVisibleInDownloadsUi = true;
|
|
/**
|
* @param uri
|
* the HTTP URI to download.
|
*/
|
public Request(Uri uri) {
|
if (uri == null) {
|
throw new NullPointerException();
|
}
|
String scheme = uri.getScheme();
|
if (scheme == null || !scheme.equals("http")) {
|
throw new IllegalArgumentException(
|
"Can only download HTTP URIs: " + uri);
|
}
|
mUri = uri;
|
}
|
|
/**
|
* m3u8鐨勮棰戞牸寮�
|
*
|
* @param uri
|
* @param type
|
*/
|
public Request(Uri uri, int type) {
|
if (uri == null) {
|
throw new NullPointerException();
|
}
|
String scheme = uri.getScheme();
|
if (scheme == null || !scheme.equals("http")) {
|
throw new IllegalArgumentException(
|
"Can only download HTTP URIs: " + uri);
|
}
|
// 涓嬭浇m3u8鐨勬枃浠�
|
|
// 瑙ｆ瀽鏂囦欢
|
|
mUri = uri;
|
}
|
|
/**
|
* Set the local destination for the downloaded file. Must be a file URI
|
* to a path on external storage, and the calling application must have
|
* the WRITE_EXTERNAL_STORAGE permission.
|
*
|
* If the URI is a directory(ending with "/"), destination filename will
|
* be generated.
|
*
|
* @return this object
|
*/
|
public Request setDestinationUri(Uri uri) {
|
Uri ur = Uri.withAppendedPath(uri, System.currentTimeMillis() + ""
|
+ (int) (Math.random() * 10000));
|
mDestinationUri = ur;
|
/*
|
* File f = new File(ur.getPath()); if (!f.exists()) try {
|
* f.createNewFile(); } catch (IOException e) { // TODO
|
* Auto-generated catch block e.printStackTrace(); }
|
*/
|
Log.i(TAG, "setDestinationUri:" + ur.getPath());
|
return this;
|
}
|
|
/**
|
* Set the local destination for the downloaded file to a path within
|
* the application's external files directory (as returned by
|
* {@link Context#getExternalFilesDir(String)}.
|
*
|
* @param context
|
* the {@link Context} to use in determining the external
|
* files directory
|
* @param dirType
|
* the directory type to pass to
|
* {@link Context#getExternalFilesDir(String)}
|
* @param subPath
|
* the path within the external directory. If subPath is a
|
* directory(ending with "/"), destination filename will be
|
* generated.
|
* @return this object
|
*/
|
public Request setDestinationInExternalFilesDir(Context context,
|
String dirType, String subPath) {
|
setDestinationFromBase(context.getExternalFilesDir(dirType),
|
subPath);
|
return this;
|
}
|
|
/**
|
* Set the local destination for the downloaded file to a path within
|
* the public external storage directory (as returned by
|
* {@link Environment#getExternalStoragePublicDirectory(String)}.
|
*
|
* @param dirType
|
* the directory type to pass to
|
* {@link Environment#getExternalStoragePublicDirectory(String)}
|
* @param subPath
|
* the path within the external directory. If subPath is a
|
* directory(ending with "/"), destination filename will be
|
* generated.
|
* @return this object
|
*/
|
public Request setDestinationInExternalPublicDir(String dirType,
|
String subPath) {
|
setDestinationFromBase(
|
Environment.getExternalStoragePublicDirectory(dirType),
|
subPath);
|
return this;
|
}
|
|
public void setDestinationFromBase(File base, String subPath) {
|
if (subPath == null) {
|
throw new NullPointerException("subPath cannot be null");
|
}
|
|
mDestinationUri = Uri.withAppendedPath(Uri.fromFile(base), subPath);
|
Log.i(TAG, subPath);
|
}
|
|
/**
|
* Add an HTTP header to be included with the download request. The
|
* header will be added to the end of the list.
|
*
|
* @param header
|
* HTTP header name
|
* @param value
|
* header value
|
* @return this object
|
* @see <a
|
* href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2">HTTP/1.1
|
* Message Headers</a>
|
*/
|
public Request addRequestHeader(String header, String value) {
|
if (header == null) {
|
throw new NullPointerException("header cannot be null");
|
}
|
if (header.contains(":")) {
|
throw new IllegalArgumentException("header may not contain ':'");
|
}
|
if (value == null) {
|
value = "";
|
}
|
mRequestHeaders.add(Pair.create(header, value));
|
return this;
|
}
|
|
/**
|
* Set the title of this download, to be displayed in notifications (if
|
* enabled). If no title is given, a default one will be assigned based
|
* on the download filename, once the download starts.
|
*
|
* @return this object
|
*/
|
public Request setTitle(CharSequence title) {
|
mTitle = title;
|
return this;
|
}
|
|
/**
|
* Set a description of this download, to be displayed in notifications
|
* (if enabled)
|
*
|
* @return this object
|
*/
|
public Request setDescription(CharSequence description) {
|
mDescription = description;
|
return this;
|
}
|
|
/**
|
* Set the MIME content type of this download. This will override the
|
* content type declared in the server's response.
|
*
|
* @see <a
|
* href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7">HTTP/1.1
|
* Media Types</a>
|
* @return this object
|
*/
|
public Request setMimeType(String mimeType) {
|
mMimeType = mimeType;
|
return this;
|
}
|
|
/**
|
* Control whether a system notification is posted by the download
|
* manager while this download is running. If enabled, the download
|
* manager posts notifications about downloads through the system
|
* {@link com.mozillaonline.providers.NotificationManager}. By default,
|
* a notification is shown.
|
*
|
* If set to false, this requires the permission
|
* android.permission.DOWNLOAD_WITHOUT_NOTIFICATION.
|
*
|
* @param show
|
* whether the download manager should show a notification
|
* for this download.
|
* @return this object
|
*/
|
public Request setShowRunningNotification(boolean show) {
|
mShowNotification = show;
|
return this;
|
}
|
|
/**
|
* Restrict the types of networks over which this download may proceed.
|
* By default, all network types are allowed.
|
*
|
* @param flags
|
* any combination of the NETWORK_* bit flags.
|
* @return this object
|
*/
|
public Request setAllowedNetworkTypes(int flags) {
|
mAllowedNetworkTypes = flags;
|
return this;
|
}
|
|
/**
|
* Set whether this download may proceed over a roaming connection. By
|
* default, roaming is allowed.
|
*
|
* @param allowed
|
* whether to allow a roaming connection to be used
|
* @return this object
|
*/
|
public Request setAllowedOverRoaming(boolean allowed) {
|
mRoamingAllowed = allowed;
|
return this;
|
}
|
|
/**
|
* Set whether this download should be displayed in the system's
|
* Downloads UI. True by default.
|
*
|
* @param isVisible
|
* whether to display this download in the Downloads UI
|
* @return this object
|
*/
|
public Request setVisibleInDownloadsUi(boolean isVisible) {
|
mIsVisibleInDownloadsUi = isVisible;
|
return this;
|
}
|
|
private String mUserAgent = null;
|
|
public Request setUserAgent(String userAgent) {
|
mUserAgent = userAgent;
|
return this;
|
}
|
|
/**
|
* @return ContentValues to be passed to DownloadProvider.insert()
|
*/
|
ContentValues toContentValues(String packageName) {
|
ContentValues values = new ContentValues();
|
assert mUri != null;
|
values.put(Downloads.COLUMN_URI, mUri.toString());
|
values.put(Downloads.COLUMN_IS_PUBLIC_API, true);
|
values.put(Downloads.COLUMN_USER_AGENT, mUserAgent);
|
|
values.put(Downloads.COLUMN_NOTIFICATION_PACKAGE, packageName);
|
|
if (mDestinationUri != null) {
|
values.put(Downloads.COLUMN_DESTINATION,
|
Downloads.DESTINATION_FILE_URI);
|
values.put(Downloads.COLUMN_FILE_NAME_HINT,
|
mDestinationUri.toString());
|
} else {
|
values.put(Downloads.COLUMN_DESTINATION,
|
Downloads.DESTINATION_EXTERNAL);
|
}
|
|
if (!mRequestHeaders.isEmpty()) {
|
encodeHttpHeaders(values);
|
}
|
|
putIfNonNull(values, Downloads.COLUMN_TITLE, mTitle);
|
putIfNonNull(values, Downloads.COLUMN_DESCRIPTION, mDescription);
|
putIfNonNull(values, Downloads.COLUMN_MIME_TYPE, mMimeType);
|
|
values.put(Downloads.COLUMN_VISIBILITY,
|
mShowNotification ? Downloads.VISIBILITY_VISIBLE
|
: Downloads.VISIBILITY_HIDDEN);
|
|
values.put(Downloads.COLUMN_ALLOWED_NETWORK_TYPES,
|
mAllowedNetworkTypes);
|
values.put(Downloads.COLUMN_ALLOW_ROAMING, mRoamingAllowed);
|
values.put(Downloads.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI,
|
mIsVisibleInDownloadsUi);
|
|
values.put(Downloads.COLUMN_NO_INTEGRITY, 1);
|
|
return values;
|
}
|
|
private void encodeHttpHeaders(ContentValues values) {
|
int index = 0;
|
for (Pair<String, String> header : mRequestHeaders) {
|
String headerString = header.first + ": " + header.second;
|
values.put(Downloads.RequestHeaders.INSERT_KEY_PREFIX + index,
|
headerString);
|
index++;
|
}
|
}
|
|
private void putIfNonNull(ContentValues contentValues, String key,
|
Object value) {
|
if (value != null) {
|
contentValues.put(key, value.toString());
|
}
|
}
|
}
|
|
/**
|
* This class may be used to filter download manager queries.
|
*/
|
public static class Query {
|
/**
|
* Constant for use with {@link #orderBy}
|
*
|
* @hide
|
*/
|
public static final int ORDER_ASCENDING = 1;
|
|
/**
|
* Constant for use with {@link #orderBy}
|
*
|
* @hide
|
*/
|
public static final int ORDER_DESCENDING = 2;
|
|
private long[] mIds = null;
|
private Integer mStatusFlags = null;
|
private String mOrderByColumn = Downloads.COLUMN_LAST_MODIFICATION;
|
private int mOrderDirection = ORDER_DESCENDING;
|
private boolean mOnlyIncludeVisibleInDownloadsUi = false;
|
|
/**
|
* Include only the downloads with the given IDs.
|
*
|
* @return this object
|
*/
|
public Query setFilterById(long... ids) {
|
mIds = ids;
|
return this;
|
}
|
|
/**
|
* Include only downloads with status matching any the given status
|
* flags.
|
*
|
* @param flags
|
* any combination of the STATUS_* bit flags
|
* @return this object
|
*/
|
public Query setFilterByStatus(int flags) {
|
mStatusFlags = flags;
|
return this;
|
}
|
|
/**
|
* Controls whether this query includes downloads not visible in the
|
* system's Downloads UI.
|
*
|
* @param value
|
* if true, this query will only include downloads that
|
* should be displayed in the system's Downloads UI; if false
|
* (the default), this query will include both visible and
|
* invisible downloads.
|
* @return this object
|
* @hide
|
*/
|
public Query setOnlyIncludeVisibleInDownloadsUi(boolean value) {
|
mOnlyIncludeVisibleInDownloadsUi = value;
|
return this;
|
}
|
|
/**
|
* Change the sort order of the returned Cursor.
|
*
|
* @param column
|
* one of the COLUMN_* constants; currently, only
|
* {@link #COLUMN_LAST_MODIFIED_TIMESTAMP} and
|
* {@link #COLUMN_TOTAL_SIZE_BYTES} are supported.
|
* @param direction
|
* either {@link #ORDER_ASCENDING} or
|
* {@link #ORDER_DESCENDING}
|
* @return this object
|
* @hide
|
*/
|
public Query orderBy(String column, int direction) {
|
if (direction != ORDER_ASCENDING && direction != ORDER_DESCENDING) {
|
throw new IllegalArgumentException("Invalid direction: "
|
+ direction);
|
}
|
|
if (column.equals(COLUMN_LAST_MODIFIED_TIMESTAMP)) {
|
mOrderByColumn = Downloads.COLUMN_LAST_MODIFICATION;
|
} else if (column.equals(COLUMN_TOTAL_SIZE_BYTES)) {
|
mOrderByColumn = Downloads.COLUMN_TOTAL_BYTES;
|
} else {
|
throw new IllegalArgumentException("Cannot order by " + column);
|
}
|
mOrderDirection = direction;
|
return this;
|
}
|
|
/**
|
* Run this query using the given ContentResolver.
|
*
|
* @param projection
|
* the projection to pass to ContentResolver.query()
|
* @return the Cursor returned by ContentResolver.query()
|
*/
|
Cursor runQuery(ContentResolver resolver, String[] projection,
|
Uri baseUri) {
|
Uri uri = baseUri;
|
List<String> selectionParts = new ArrayList<String>();
|
String[] selectionArgs = null;
|
|
// 按照提供的 ids数组 更新数据库下载状态
|
if (mIds != null) {
|
selectionParts.add(getWhereClauseForIds(mIds));// 插入查询条件语句
|
selectionArgs = getWhereArgsForIds(mIds);
|
}
|
|
if (mStatusFlags != null) {
|
List<String> parts = new ArrayList<String>();
|
if ((mStatusFlags & STATUS_PENDING) != 0) {
|
parts.add(statusClause("=", Downloads.STATUS_PENDING));
|
}
|
if ((mStatusFlags & STATUS_RUNNING) != 0) {
|
parts.add(statusClause("=", Downloads.STATUS_RUNNING));
|
}
|
if ((mStatusFlags & STATUS_PAUSED) != 0) {
|
parts.add(statusClause("=", Downloads.STATUS_PAUSED_BY_APP));
|
parts.add(statusClause("=",
|
Downloads.STATUS_WAITING_TO_RETRY));
|
parts.add(statusClause("=",
|
Downloads.STATUS_WAITING_FOR_NETWORK));
|
parts.add(statusClause("=",
|
Downloads.STATUS_QUEUED_FOR_WIFI));
|
}
|
if ((mStatusFlags & STATUS_SUCCESSFUL) != 0) {
|
parts.add(statusClause("=", Downloads.STATUS_SUCCESS));
|
}
|
if ((mStatusFlags & STATUS_FAILED) != 0) {
|
parts.add("(" + statusClause(">=", 400) + " AND "
|
+ statusClause("<", 600) + ")");
|
}
|
selectionParts.add(joinStrings(" OR ", parts));
|
}
|
|
if (mOnlyIncludeVisibleInDownloadsUi) {
|
selectionParts.add(Downloads.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI
|
+ " != '0'");
|
}
|
|
// only return rows which are not marked 'deleted = 1'
|
selectionParts.add(Downloads.COLUMN_DELETED + " != '1'");
|
|
String selection = joinStrings(" AND ", selectionParts);
|
String orderDirection = (mOrderDirection == ORDER_ASCENDING ? "ASC"
|
: "DESC");
|
String orderBy = mOrderByColumn + " " + orderDirection;
|
|
return resolver.query(uri, projection, selection, selectionArgs,
|
null);
|
// return resolver.query(uri, projection, selection, selectionArgs,
|
// orderBy);
|
}
|
|
private String joinStrings(String joiner, Iterable<String> parts) {
|
StringBuilder builder = new StringBuilder();
|
boolean first = true;
|
for (String part : parts) {
|
if (!first) {
|
builder.append(joiner);
|
}
|
builder.append(part);
|
first = false;
|
}
|
return builder.toString();
|
}
|
|
private String statusClause(String operator, int value) {
|
return Downloads.COLUMN_STATUS + operator + "'" + value + "'";
|
}
|
}
|
|
private ContentResolver mResolver;
|
private String mPackageName;
|
private Uri mBaseUri = Downloads.CONTENT_URI;
|
|
/**
|
* @hide
|
*/
|
public DownloadManager(ContentResolver resolver, String packageName) {
|
mResolver = resolver;
|
mPackageName = packageName;
|
}
|
|
/**
|
* Makes this object access the download provider through /all_downloads
|
* URIs rather than /my_downloads URIs, for clients that have permission to
|
* do so.
|
*
|
* @hide
|
*/
|
public void setAccessAllDownloads(boolean accessAllDownloads) {
|
if (accessAllDownloads) {
|
mBaseUri = Downloads.ALL_DOWNLOADS_CONTENT_URI;
|
} else {
|
mBaseUri = Downloads.CONTENT_URI;
|
}
|
}
|
|
/**
|
* Enqueue a new download. The download will start automatically once the
|
* download manager is ready to execute it and connectivity is available.
|
* 开启一个新的下载，在下载管理器连接可用并已经准备好后会自动执行一次
|
*
|
* @param request
|
* the parameters specifying this download
|
* @return an ID for the download, unique across the system. This ID is used
|
* to make future calls related to this download.
|
*/
|
public long enqueue(Request request) {
|
ContentValues values = request.toContentValues(mPackageName);
|
Uri downloadUri = mResolver.insert(Downloads.CONTENT_URI, values);
|
long id = Long.parseLong(downloadUri.getLastPathSegment());
|
return id;
|
}
|
|
/**
|
* Marks the specified download as 'to be deleted'. This is done when a
|
* completed download is to be removed but the row was stored without enough
|
* info to delete the corresponding metadata from Mediaprovider database.
|
* Actual cleanup of this row is done in DownloadService.
|
*
|
* @param ids
|
* the IDs of the downloads to be marked 'deleted'
|
* @return the number of downloads actually updated
|
* @hide
|
*/
|
public int markRowDeleted(long... ids) {
|
if (ids == null || ids.length == 0) {
|
// called with nothing to remove!
|
throw new IllegalArgumentException(
|
"input param 'ids' can't be null");
|
}
|
ContentValues values = new ContentValues();
|
values.put(Downloads.COLUMN_DELETED, 1);
|
return mResolver.update(mBaseUri, values, getWhereClauseForIds(ids),
|
getWhereArgsForIds(ids));
|
}
|
|
/**
|
* Cancel downloads and remove them from the download manager. Each download
|
* will be stopped if it was running, and it will no longer be accessible
|
* through the download manager. If a file was already downloaded to
|
* external storage, it will not be deleted.
|
*
|
* @param ids
|
* the IDs of the downloads to remove
|
* @return the number of downloads actually removed
|
*/
|
public int remove(long... ids) {
|
if (ids == null || ids.length == 0) {
|
// called with nothing to remove!
|
throw new IllegalArgumentException(
|
"input param 'ids' can't be null");
|
}
|
return mResolver.delete(mBaseUri, getWhereClauseForIds(ids),
|
getWhereArgsForIds(ids));
|
}
|
|
/**
|
* Query the download manager about downloads that have been requested.
|
*
|
* @param query
|
* parameters specifying filters for this query
|
* @return a Cursor over the result set of downloads, with columns
|
* consisting of all the COLUMN_* constants.
|
*/
|
public Cursor query(Query query) {
|
Cursor underlyingCursor = query.runQuery(mResolver, UNDERLYING_COLUMNS,
|
mBaseUri);
|
if (underlyingCursor == null) {
|
return null;
|
}
|
return new CursorTranslator(underlyingCursor, mBaseUri);
|
}
|
|
/**
|
* Open a downloaded file for reading. The download must have completed.
|
*
|
* @param id
|
* the ID of the download
|
* @return a read-only {@link ParcelFileDescriptor}
|
* @throws FileNotFoundException
|
* if the destination file does not already exist
|
*/
|
public ParcelFileDescriptor openDownloadedFile(long id)
|
throws FileNotFoundException {
|
return mResolver.openFileDescriptor(getDownloadUri(id), "r");
|
}
|
|
/**
|
* Pause the given downloads, which must be running. This method will only
|
* work when called from within the download manager's process.
|
*
|
* @param ids
|
* the IDs of the downloads
|
* @hide
|
*/
|
public void pauseDownload(long... ids) {
|
boolean noError = true;
|
Cursor cursor = query(new Query().setFilterById(ids));
|
try {
|
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor
|
.moveToNext()) {
|
int status = cursor
|
.getInt(cursor.getColumnIndex(COLUMN_STATUS));
|
if (status != STATUS_RUNNING && status != STATUS_PENDING) {
|
noError = false;
|
// throw new IllegalArgumentException(
|
// "Can only pause a running download: "
|
// + cursor.getLong(cursor
|
// .getColumnIndex(COLUMN_ID)));
|
}
|
}
|
} finally {
|
cursor.close();
|
}
|
|
if (noError) {
|
ContentValues values = new ContentValues();
|
values.put(Downloads.COLUMN_CONTROL, Downloads.CONTROL_PAUSED);
|
values.put(Downloads.COLUMN_NO_INTEGRITY, Downloads.CONTROL_PAUSED);
|
values.put(Downloads.COLUMN_STATUS, Downloads.CONTROL_PAUSED);
|
mResolver.update(mBaseUri, values, getWhereClauseForIds(ids),
|
getWhereArgsForIds(ids));
|
}
|
}
|
|
/**
|
* Resume the given downloads, which must be paused. This method will only
|
* work when called from within the download manager's process.
|
*
|
* @param ids
|
* the IDs of the downloads
|
* @hide
|
*/
|
public void resumeDownload(long... ids) {
|
boolean noError = true;
|
Cursor cursor = query(new Query().setFilterById(ids));
|
try {
|
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor
|
.moveToNext()) {
|
int status = cursor
|
.getInt(cursor.getColumnIndex(COLUMN_STATUS));
|
if (status != STATUS_PAUSED) {
|
noError = false;
|
// throw new IllegalArgumentException(
|
// "Cann only resume a paused download: "
|
// + cursor.getLong(cursor
|
// .getColumnIndex(COLUMN_ID)));
|
}
|
}
|
} finally {
|
cursor.close();
|
}
|
|
if (noError) {
|
ContentValues values = new ContentValues();
|
values.put(Downloads.COLUMN_STATUS, Downloads.STATUS_PENDING);
|
values.put(Downloads.COLUMN_CONTROL, Downloads.CONTROL_RUN);
|
mResolver.update(mBaseUri, values, getWhereClauseForIds(ids),
|
getWhereArgsForIds(ids));
|
}
|
}
|
|
/**
|
* Resume the given downloads, which must be paused. This method will only
|
* work when called from within the download manager's process.
|
*
|
* @param ids
|
* the IDs of the downloads
|
* @hide
|
*/
|
public void startDownload(long... ids) {
|
boolean noError = true;
|
Cursor cursor = query(new Query().setFilterById(ids));
|
try {
|
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor
|
.moveToNext()) {
|
int status = cursor
|
.getInt(cursor.getColumnIndex(COLUMN_STATUS));
|
if (status != STATUS_PENDING) {
|
noError = false;
|
// throw new IllegalArgumentException(
|
// "Cann only resume a paused download: "
|
// + cursor.getLong(cursor
|
// .getColumnIndex(COLUMN_ID)));
|
}
|
}
|
} finally {
|
cursor.close();
|
}
|
|
if (noError) {
|
|
ContentValues values1 = new ContentValues();
|
values1.put(Downloads.COLUMN_STATUS, Downloads.STATUS_PENDING);
|
values1.put(Downloads.COLUMN_CONTROL, Downloads.CONTROL_PENDING);
|
values1.put(Downloads.COLUMN_NO_INTEGRITY, Downloads.CONTROL_PAUSED);
|
mResolver.update(mBaseUri, values1, Downloads.COLUMN_STATUS + "=?",
|
new String[] { Downloads.STATUS_RUNNING + "" });
|
|
ContentValues values = new ContentValues();
|
values.put(Downloads.COLUMN_STATUS, Downloads.STATUS_RUNNING);
|
values.put(Downloads.COLUMN_CONTROL, Downloads.CONTROL_RUN);
|
mResolver.update(mBaseUri, values, getWhereClauseForIds(ids),
|
getWhereArgsForIds(ids));
|
}
|
}
|
|
/**
|
* Restart the given downloads, which must have already completed
|
* (successfully or not). This method will only work when called from within
|
* the download manager's process.
|
*
|
* * @param ids the IDs of the downloads
|
*
|
* @hide
|
*/
|
public void restartDownload(long... ids) {
|
Cursor cursor = query(new Query().setFilterById(ids));
|
try {
|
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor
|
.moveToNext()) {
|
int status = cursor
|
.getInt(cursor.getColumnIndex(COLUMN_STATUS));
|
if (status != STATUS_SUCCESSFUL && status != STATUS_FAILED) {
|
throw new IllegalArgumentException(
|
|
"Cannot restart incomplete download: "
|
+ cursor.getLong(cursor.getColumnIndex(COLUMN_ID)));
|
}
|
}
|
} finally {
|
cursor.close();
|
}
|
ContentValues values = new ContentValues();
|
values.put(Downloads.COLUMN_CURRENT_BYTES, 0);
|
values.put(Downloads.COLUMN_TOTAL_BYTES, -1);
|
values.putNull(Downloads._DATA);
|
values.put(Downloads.COLUMN_STATUS, Downloads.STATUS_PENDING);
|
mResolver.update(mBaseUri, values, getWhereClauseForIds(ids),
|
getWhereArgsForIds(ids));
|
}
|
|
/**
|
* Get the DownloadProvider URI for the download with the given ID.
|
*/
|
Uri getDownloadUri(long id) {
|
return ContentUris.withAppendedId(mBaseUri, id);
|
}
|
|
/**
|
* Get a parameterized SQL WHERE clause to select a bunch of IDs.
|
* 得到一个参数化的SQL WHERE子句通过选择一组ID。
|
*/
|
static String getWhereClauseForIds(long[] ids) {
|
StringBuilder whereClause = new StringBuilder();
|
whereClause.append("(");
|
for (int i = 0; i < ids.length; i++) {
|
if (i > 0) {
|
whereClause.append("OR ");
|
}
|
whereClause.append(Downloads._ID);
|
whereClause.append(" = ? ");
|
}
|
whereClause.append(")");
|
return whereClause.toString();
|
}
|
|
/**
|
* Get the selection args for a clause returned by
|
* {@link #getWhereClauseForIds(long[])}. 获取选择的args通过返回项
|
* {@link#getWhereClauseForIds（长[]）}。
|
*/
|
static String[] getWhereArgsForIds(long[] ids) {
|
String[] whereArgs = new String[ids.length];
|
for (int i = 0; i < ids.length; i++) {
|
whereArgs[i] = Long.toString(ids[i]);//
|
}
|
return whereArgs;
|
}
|
|
/**
|
* This class wraps a cursor returned by DownloadProvider -- the
|
* "underlying cursor" -- and presents a different set of columns, those
|
* defined in the DownloadManager.COLUMN_* constants. Some columns
|
* correspond directly to underlying values while others are computed from
|
* underlying data.
|
*/
|
private static class CursorTranslator extends CursorWrapper {
|
public CursorTranslator(Cursor cursor, Uri baseUri) {
|
super(cursor);
|
}
|
|
@Override
|
public int getColumnIndex(String columnName) {
|
return Arrays.asList(COLUMNS).indexOf(columnName);
|
}
|
|
@Override
|
public int getColumnIndexOrThrow(String columnName)
|
throws IllegalArgumentException {
|
int index = getColumnIndex(columnName);
|
if (index == -1) {
|
throw new IllegalArgumentException("No such column: "
|
+ columnName);
|
}
|
return index;
|
}
|
|
@Override
|
public String getColumnName(int columnIndex) {
|
int numColumns = COLUMNS.length;
|
if (columnIndex < 0 || columnIndex >= numColumns) {
|
throw new IllegalArgumentException("Invalid column index "
|
+ columnIndex + ", " + numColumns + " columns exist");
|
}
|
return COLUMNS[columnIndex];
|
}
|
|
@Override
|
public String[] getColumnNames() {
|
String[] returnColumns = new String[COLUMNS.length];
|
System.arraycopy(COLUMNS, 0, returnColumns, 0, COLUMNS.length);
|
return returnColumns;
|
}
|
|
@Override
|
public int getColumnCount() {
|
return COLUMNS.length;
|
}
|
|
@Override
|
public byte[] getBlob(int columnIndex) {
|
throw new UnsupportedOperationException();
|
}
|
|
@Override
|
public double getDouble(int columnIndex) {
|
return getLong(columnIndex);
|
}
|
|
private boolean isLongColumn(String column) {
|
return LONG_COLUMNS.contains(column);
|
}
|
|
@Override
|
public float getFloat(int columnIndex) {
|
return (float) getDouble(columnIndex);
|
}
|
|
@Override
|
public int getInt(int columnIndex) {
|
return (int) getLong(columnIndex);
|
}
|
|
@Override
|
public long getLong(int columnIndex) {
|
return translateLong(getColumnName(columnIndex));
|
}
|
|
@Override
|
public short getShort(int columnIndex) {
|
return (short) getLong(columnIndex);
|
}
|
|
@Override
|
public String getString(int columnIndex) {
|
return translateString(getColumnName(columnIndex));
|
}
|
|
private String translateString(String column) {
|
if (isLongColumn(column)) {
|
return Long.toString(translateLong(column));
|
}
|
if (column.equals(COLUMN_TITLE)) {
|
return getUnderlyingString(Downloads.COLUMN_TITLE);
|
}
|
if (column.equals(COLUMN_DESCRIPTION)) {
|
return getUnderlyingString(Downloads.COLUMN_DESCRIPTION);
|
}
|
if (column.equals(COLUMN_URI)) {
|
return getUnderlyingString(Downloads.COLUMN_URI);
|
}
|
if (column.equals(COLUMN_MEDIA_TYPE)) {
|
return getUnderlyingString(Downloads.COLUMN_MIME_TYPE);
|
}
|
|
assert column.equals(COLUMN_LOCAL_URI);
|
return getLocalUri();
|
}
|
|
private String getLocalUri() {
|
String localPath = getUnderlyingString(Downloads._DATA);
|
if (localPath == null) {
|
return null;
|
}
|
return Uri.fromFile(new File(localPath)).toString();
|
}
|
|
private long translateLong(String column) {
|
if (!isLongColumn(column)) {
|
// mimic behavior of underlying cursor -- most likely, throw
|
// NumberFormatException
|
return Long.valueOf(translateString(column));
|
}
|
|
if (column.equals(COLUMN_ID)) {
|
return getUnderlyingLong(Downloads._ID);
|
}
|
if (column.equals(COLUMN_TOTAL_SIZE_BYTES)) {
|
return getUnderlyingLong(Downloads.COLUMN_TOTAL_BYTES);
|
}
|
if (column.equals(COLUMN_STATUS)) {
|
return translateStatus((int) getUnderlyingLong(Downloads.COLUMN_STATUS));
|
}
|
if (column.equals(COLUMN_REASON)) {
|
return getReason((int) getUnderlyingLong(Downloads.COLUMN_STATUS));
|
}
|
if (column.equals(COLUMN_BYTES_DOWNLOADED_SO_FAR)) {
|
return getUnderlyingLong(Downloads.COLUMN_CURRENT_BYTES);
|
}
|
assert column.equals(COLUMN_LAST_MODIFIED_TIMESTAMP);
|
return getUnderlyingLong(Downloads.COLUMN_LAST_MODIFICATION);
|
}
|
|
private long getReason(int status) {
|
switch (translateStatus(status)) {
|
case STATUS_FAILED:
|
return getErrorCode(status);
|
|
case STATUS_PAUSED:
|
return getPausedReason(status);
|
|
default:
|
return 0; // arbitrary value when status is not an error
|
}
|
}
|
|
private long getPausedReason(int status) {
|
switch (status) {
|
case Downloads.STATUS_WAITING_TO_RETRY:
|
return PAUSED_WAITING_TO_RETRY;
|
|
case Downloads.STATUS_WAITING_FOR_NETWORK:
|
return PAUSED_WAITING_FOR_NETWORK;
|
|
case Downloads.STATUS_QUEUED_FOR_WIFI:
|
return PAUSED_QUEUED_FOR_WIFI;
|
|
default:
|
return PAUSED_UNKNOWN;
|
}
|
}
|
|
private long getErrorCode(int status) {
|
if ((400 <= status && status < Downloads.MIN_ARTIFICIAL_ERROR_STATUS)
|
|| (500 <= status && status < 600)) {
|
// HTTP status code
|
return status;
|
}
|
|
switch (status) {
|
case Downloads.STATUS_FILE_ERROR:
|
return ERROR_FILE_ERROR;
|
|
case Downloads.STATUS_UNHANDLED_HTTP_CODE:
|
case Downloads.STATUS_UNHANDLED_REDIRECT:
|
return ERROR_UNHANDLED_HTTP_CODE;
|
|
case Downloads.STATUS_HTTP_DATA_ERROR:
|
return ERROR_HTTP_DATA_ERROR;
|
|
case Downloads.STATUS_TOO_MANY_REDIRECTS:
|
return ERROR_TOO_MANY_REDIRECTS;
|
|
case Downloads.STATUS_INSUFFICIENT_SPACE_ERROR:
|
return ERROR_INSUFFICIENT_SPACE;
|
|
case Downloads.STATUS_DEVICE_NOT_FOUND_ERROR:
|
return ERROR_DEVICE_NOT_FOUND;
|
|
case Downloads.STATUS_CANNOT_RESUME:
|
return ERROR_CANNOT_RESUME;
|
|
case Downloads.STATUS_FILE_ALREADY_EXISTS_ERROR:
|
return ERROR_FILE_ALREADY_EXISTS;
|
|
default:
|
return ERROR_UNKNOWN;
|
}
|
}
|
|
private long getUnderlyingLong(String column) {
|
return super.getLong(super.getColumnIndex(column));
|
}
|
|
private String getUnderlyingString(String column) {
|
return super.getString(super.getColumnIndex(column));
|
}
|
|
private int translateStatus(int status) {
|
switch (status) {
|
case Downloads.STATUS_PENDING:
|
return STATUS_PENDING;
|
|
case Downloads.STATUS_RUNNING:
|
return STATUS_RUNNING;
|
|
case Downloads.STATUS_PAUSED_BY_APP:
|
case Downloads.STATUS_WAITING_TO_RETRY:
|
case Downloads.STATUS_WAITING_FOR_NETWORK:
|
case Downloads.STATUS_QUEUED_FOR_WIFI:
|
case 1:
|
return STATUS_PAUSED;
|
|
case Downloads.STATUS_SUCCESS:
|
return STATUS_SUCCESSFUL;
|
|
default:
|
assert Downloads.isStatusError(status);
|
return STATUS_FAILED;
|
}
|
}
|
}
|
}
|
