zoukankan      html  css  js  c++  java

  • Android 下载模块分析(DownloadManager和DownloadProvider)

           Android下载模块主要有2个部分组成：DownloadManager和DownloadProvider；其中DownloadManager提供接口供调用，具体的实现是 DownloadProvider，包括相关数据信息的保存及文件下载。
        
           DownloadManager是系统开放给第三方应用使用的类，包含两个静态内部类DownloadManager.Query和DownloadManager.Request。
    • DownloadManager.Request用来请求一个下载
    • DownloadManager.Query 用来查询下载信息
    DownloadManager主要提供了一下主要方法
    • enqueue(Request request)：执行下载，返回downloadId,downloadId可用于查询下载信息。
    • remove(long ids)：删除下载，若下载中取消下载。会同时删除下载文件和记录。
    • query(Query query)查询下载信息
    • getMaxBytesOverMobile(Context context)通过移动网络下载的最大字节数
    • getMimeTypeForDownloadedFile(long id)得到下载的mineType
     
        通过查看代码我们可以发现还有个CursorTranslator私有静态内部类。这个类主要对Query做了一层代理。将DownloadProvider和DownloadManager之间做个映射。将DownloadProvider中的十几种状态对应到了DownloadManager中的五种状态，DownloadProvider中的失败、暂停原因转换为了DownloadManager的原因。

    1.DownloadManager的一般用法
    1.1 调用DownloadManager.Request开始下载
     在开始之前，在AndroidManifest.xml中添加网络访问权限和sdcard写入权限。
    1. <uses-permission android:name="android.permission.INTERNET" />
    2. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    接着，调用DownloadManager.Request开始下载
    1. DownloadManagerdownloadManager=(DownloadManager)getSystemService(DOWNLOAD_SERVICE);
    2. //文件下载地址
    3. String url="http://v.yingshibao.chuanke.com//001_zongshu.mp4";
    4. //创建一个Request对象
    5. DownloadManager.Request request=newDownloadManager.Request(Uri.parse(url));
    6. //设置下载文件路径
    7. request.setDestinationInExternalPublicDir("itbox","zongshu.mp4");
    8. //开始下载
    9. longdownloadId=downloadManager.enqueue(request);
    DownloadManager.Request一些常用方法：
    • setDestinationInExternalFilesDir 设置文件下载路径
    • allowScanningByMediaScanner() 表示允许MediaScanner扫描到这个文件夹，默认不允许。
    • setTitle()设置下载中通知栏提示的标题
    • setDescription()设置下载中通知栏提示的介绍。
    • setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)表示下载进行中和下载完成的通知栏是否显示。默认只显示下载中通知。VISIBILITY_VISIBLE_NOTIFY_COMPLETED表示下载完成后显示通知栏提示。VISIBILITY_HIDDEN表示不显示任何通知栏提示，这个需要在AndroidMainfest中添加权限android.permission.DOWNLOAD_WITHOUT_NOTIFICATION.
    • request.setAllowedNetworkTypes(DownloadManager.Request.NETWORK_WIFI) 表示下载允许的网络类型，默认在任何网络下都允许下载。有NETWORK_MOBILE、NETWORK_WIFI、NETWORK_BLUETOOTH三种及其组合可供选择。如果只允许wifi下载，而当前网络为3g，则下载会等待。
    • request.setAllowedOverRoaming(boolean allow)移动网络情况下是否允许漫游。
    • request.setMimeType() 设置下载文件的mineType。因为下载管理Ui中点击某个已下载完成文件及下载完成点击通知栏提示都会根据mimeType去打开文件。
    • request.addRequestHeader(String header, String value)添加请求下载的网络链接的http头，比如User-Agent，gzip压缩等
     
    1.2 下载进度查询
    DownloadManager下载过程中，会将下载的数据和下载的状态插入ContentProvider中，所以我们可以通过注册一个ContentObserver，通过ContentObserver不断获取数据，对UI进行更新。
     
    我们主要调用DownloadManager.Query()进行查询，DownloadManager.Query为下载管理对外开放的信息查询类，主要包括以下方法：
    * setFilterById(long… ids)根据下载id进行过滤
    * setFilterByStatus(int flags)根据下载状态进行过滤
    * setOnlyIncludeVisibleInDownloadsUi(boolean value)根据是否在download ui中可见进行过滤。
    * orderBy(String column, int direction)根据列进行排序，不过目前仅支持DownloadManager.COLUMN_LAST_MODIFIED_TIMESTAMP和DownloadManager.COLUMN_TOTAL_SIZE_BYTES排序。
    1. class DownloadChangeObserver extends ContentObserver {
    2. 		private Handler handler;
    3. 		private long downloadId;
    5. 		public DownloadChangeObserver(Handler handler, long downloadId) {
    6. 			super(handler);
    7. 			this.handler = handler;
    8. 			this.downloadId = downloadId;
    9. 		}
    11. 		@Override
    12. 		public void onChange(boolean selfChange) {
    13. 			updateView(handler, downloadId);
    14. 		}
    15. 	}
    注册ContentResolver
    1.  
    2. mContext.getContentResolver().registerContentObserver(
    3.    Uri.parse("content://downloads/my_downloads"),
    4.    true,
    5.    new DownloadChangeObserver(handler,downloadId)
    6. );
    updateView()方法，获取进度，通过handle发送消息，更新UI
    1. public void updateView(Handler handler, long downloadId) {
    2. 	// 获取状态和字节
    3. 	int[] bytesAndStatus = getBytesAndStatus(downloadId);
    4. 	//
    5. 	handler.sendMessage(handler.obtainMessage(0, bytesAndStatus[0],
    6. 				bytesAndStatus[1], bytesAndStatus[2]));
    7. }
    9. public int[] getBytesAndStatus(long downloadId) {
    10. 	int[] bytesAndStatus = new int[] { -1, -1, 0 };
    11. 	DownloadManager.Query query = new DownloadManager.Query()
    12. 				.setFilterById(downloadId);
    13. 	Cursor c = null;
    14. 	try {
    15. 		c = downloadManager.query(query);
    16. 		if (c != null && c.moveToFirst()) {
    17. 			// 当前下载的字节
    18. 			bytesAndStatus[0] = c.getInt(c.getColumnIndexOrThrow(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
    19. 			// 总字节数
    20. 			bytesAndStatus[1] = c.getInt(c.getColumnIndexOrThrow(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
    21. 			// 状态
    22. 			bytesAndStatus[2] = c.getInt(c.getColumnIndex(DownloadManager.COLUMN_STATUS));
    23. 		}
    24. 	} finally {
    25. 		if (c != null) {
    26. 			c.close();
    27. 		}
    28. 	}
    29. 	return bytesAndStatus;
    30. }

     
    1.3 下载成功监听
    下载完成后，下载管理会发出DownloadManager.ACTION_DOWNLOAD_COMPLETE这个广播，并传递downloadId作为参数。通过接受广播我们可以打开对下载完成的内容进行操作。
    1. registerReceiver(receiver, new IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE));
    3. BroadcastReceiver receiver = new BroadcastReceiver() {
    5.    @Override
    6.    public void onReceive(Context context, Intent intent) {
    7.       String action = intent.getAction();
    8.       if (DownloadManager.ACTION_DOWNLOAD_COMPLETE.equals(action)) {
    9.           Log.v("chadm", "action = " + action);
    10.       }
    11.    }
    12. };


    2.下载流程分析
    2.1使用DownloadManager启动下载流程
        具体流程如时序图所示：

    a.）enqueue执行一个下载任务
    文件位置framewok/base/core/java/android/app/DownloadManager.java
    1.    public long enqueue(Request request) {
    2.         ContentValues values = request.toContentValues(mPackageName);
    3.         Uri downloadUri = mResolver.insert(Downloads.Impl.CONTENT_URI, values);
    4.         long id = Long.parseLong(downloadUri.getLastPathSegment());
    5.         return id;
    6.     }
    首先将Request对象中包含的信息转换成ContentValues对象，然后将ContentValues对象插入到DownloadProvider里面。此方法会返回一个long类型值，此值即为该条下载记录的id值

    b.)insert，将数据插入到DB对应表里面
    文件位置packages/providers/com.android.providers.downloads/DownloadProvider.java
    1.    /**
    2.      * Inserts a row in the database
    3.      */
    4.     @Override
    5.     public Uri insert(final Uri uri, final ContentValues values) {
    6.         //检查权限，如果没有相应权限，则remove相关数据，插入一条空记录
    7.         checkInsertPermissions(values);
    8.         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    10.         // note we disallow inserting into ALL_DOWNLOADS
    11.         int match = sURIMatcher.match(uri);
    12.         //判断Uri，只支持对MY_DOWNLOADS的插入操作
    13.         if (match != MY_DOWNLOADS) {
    14.             Log.d(Constants.TAG, "calling insert on an unknown/invalid URI: " + uri);
    15.             throw new IllegalArgumentException("Unknown/Invalid URI " + uri);
    16.         }
    18.         // copy some of the input values as it
    19.         ContentValues filteredValues = new ContentValues();
    20.         copyString(Downloads.Impl.COLUMN_URI, values, filteredValues);
    21.         copyString(Downloads.Impl.COLUMN_APP_DATA, values, filteredValues);
    22.         copyBoolean(Downloads.Impl.COLUMN_NO_INTEGRITY, values, filteredValues);
    23.         copyString(Downloads.Impl.COLUMN_FILE_NAME_HINT, values, filteredValues);
    24.         copyString(Downloads.Impl.COLUMN_MIME_TYPE, values, filteredValues);
    25.         copyBoolean(Downloads.Impl.COLUMN_IS_PUBLIC_API, values, filteredValues);
    27.         boolean isPublicApi =
    28.                 values.getAsBoolean(Downloads.Impl.COLUMN_IS_PUBLIC_API) == Boolean.TRUE;
    30.         // validate the destination column
    31.         Integer dest = values.getAsInteger(Downloads.Impl.COLUMN_DESTINATION);
    32.         if (dest != null) {
    33.             if (getContext().checkCallingPermission(Downloads.Impl.PERMISSION_ACCESS_ADVANCED)
    34.                     != PackageManager.PERMISSION_GRANTED
    35.                     && (dest == Downloads.Impl.DESTINATION_CACHE_PARTITION
    36.                             || dest == Downloads.Impl.DESTINATION_CACHE_PARTITION_NOROAMING
    37.                             || dest == Downloads.Impl.DESTINATION_SYSTEMCACHE_PARTITION)) {
    38.                 throw new SecurityException("setting destination to : " + dest +
    39.                         " not allowed, unless PERMISSION_ACCESS_ADVANCED is granted");
    40.             }
    41.             // for public API behavior, if an app has CACHE_NON_PURGEABLE permission, automatically
    42.             // switch to non-purgeable download
    43.             boolean hasNonPurgeablePermission =
    44.                     getContext().checkCallingPermission(
    45.                             Downloads.Impl.PERMISSION_CACHE_NON_PURGEABLE)
    46.                             == PackageManager.PERMISSION_GRANTED;
    47.             if (isPublicApi && dest == Downloads.Impl.DESTINATION_CACHE_PARTITION_PURGEABLE
    48.                     && hasNonPurgeablePermission) {
    49.                 dest = Downloads.Impl.DESTINATION_CACHE_PARTITION;
    50.             }
    51.             if (dest == Downloads.Impl.DESTINATION_FILE_URI) {
    52.                 getContext().enforcePermission(
    53.                         android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
    54.                         Binder.getCallingPid(), Binder.getCallingUid(),
    55.                         "need WRITE_EXTERNAL_STORAGE permission to use DESTINATION_FILE_URI");
    56.                 checkFileUriDestination(values);
    57.             } else if (dest == Downloads.Impl.DESTINATION_SYSTEMCACHE_PARTITION) {
    58.                 getContext().enforcePermission(
    59.                         android.Manifest.permission.ACCESS_CACHE_FILESYSTEM,
    60.                         Binder.getCallingPid(), Binder.getCallingUid(),
    61.                         "need ACCESS_CACHE_FILESYSTEM permission to use system cache");
    62.             }
    63.             filteredValues.put(Downloads.Impl.COLUMN_DESTINATION, dest);
    64.         }
    66.         // validate the visibility column
    67.         Integer vis = values.getAsInteger(Downloads.Impl.COLUMN_VISIBILITY);
    68.         if (vis == null) {
    69.             if (dest == Downloads.Impl.DESTINATION_EXTERNAL) {
    70.                 filteredValues.put(Downloads.Impl.COLUMN_VISIBILITY,
    71.                         Downloads.Impl.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
    72.             } else {
    73.                 filteredValues.put(Downloads.Impl.COLUMN_VISIBILITY,
    74.                         Downloads.Impl.VISIBILITY_HIDDEN);
    75.             }
    76.         } else {
    77.             filteredValues.put(Downloads.Impl.COLUMN_VISIBILITY, vis);
    78.         }
    79.         // copy the control column as is
    80.         copyInteger(Downloads.Impl.COLUMN_CONTROL, values, filteredValues);
    82.         /*
    83.          * requests coming from
    84.          * DownloadManager.addCompletedDownload(String, String, String,
    85.          * boolean, String, String, long) need special treatment
    86.          */
    87.         if (values.getAsInteger(Downloads.Impl.COLUMN_DESTINATION) ==
    88.                 Downloads.Impl.DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD) {
    89.             // these requests always are marked as 'completed'
    90.             filteredValues.put(Downloads.Impl.COLUMN_STATUS, Downloads.Impl.STATUS_SUCCESS);
    91.             filteredValues.put(Downloads.Impl.COLUMN_TOTAL_BYTES,
    92.                     values.getAsLong(Downloads.Impl.COLUMN_TOTAL_BYTES));
    93.             filteredValues.put(Downloads.Impl.COLUMN_CURRENT_BYTES, 0);
    94.             copyInteger(Downloads.Impl.COLUMN_MEDIA_SCANNED, values, filteredValues);
    95.             copyString(Downloads.Impl._DATA, values, filteredValues);
    96.             copyBoolean(Downloads.Impl.COLUMN_ALLOW_WRITE, values, filteredValues);
    97.         } else {
    98.             filteredValues.put(Downloads.Impl.COLUMN_STATUS, Downloads.Impl.STATUS_PENDING);
    99.             filteredValues.put(Downloads.Impl.COLUMN_TOTAL_BYTES, -1);
    100.             filteredValues.put(Downloads.Impl.COLUMN_CURRENT_BYTES, 0);
    101.         }
    103.         // set lastupdate to current time
    104.         long lastMod = mSystemFacade.currentTimeMillis();
    105.         filteredValues.put(Downloads.Impl.COLUMN_LAST_MODIFICATION, lastMod);
    107.         // use packagename of the caller to set the notification columns
    108.         String pckg = values.getAsString(Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE);
    109.         String clazz = values.getAsString(Downloads.Impl.COLUMN_NOTIFICATION_CLASS);
    110.         if (pckg != null && (clazz != null || isPublicApi)) {
    111.             int uid = Binder.getCallingUid();
    112.             try {
    113.                 if (uid == 0 || mSystemFacade.userOwnsPackage(uid, pckg)) {
    114.                     filteredValues.put(Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE, pckg);
    115.                     if (clazz != null) {
    116.                         filteredValues.put(Downloads.Impl.COLUMN_NOTIFICATION_CLASS, clazz);
    117.                     }
    118.                 }
    119.             } catch (PackageManager.NameNotFoundException ex) {
    120.                 /* ignored for now */
    121.             }
    122.         }
    124.         // copy some more columns as is
    125.         copyString(Downloads.Impl.COLUMN_NOTIFICATION_EXTRAS, values, filteredValues);
    126.         copyString(Downloads.Impl.COLUMN_COOKIE_DATA, values, filteredValues);
    127.         copyString(Downloads.Impl.COLUMN_USER_AGENT, values, filteredValues);
    128.         copyString(Downloads.Impl.COLUMN_REFERER, values, filteredValues);
    130.         // UID, PID columns
    131.         if (getContext().checkCallingPermission(Downloads.Impl.PERMISSION_ACCESS_ADVANCED)
    132.                 == PackageManager.PERMISSION_GRANTED) {
    133.             copyInteger(Downloads.Impl.COLUMN_OTHER_UID, values, filteredValues);
    134.         }
    135.         filteredValues.put(Constants.UID, Binder.getCallingUid());
    136.         if (Binder.getCallingUid() == 0) {
    137.             copyInteger(Constants.UID, values, filteredValues);
    138.         }
    140.         // copy some more columns as is
    141.         copyStringWithDefault(Downloads.Impl.COLUMN_TITLE, values, filteredValues, "");
    142.         copyStringWithDefault(Downloads.Impl.COLUMN_DESCRIPTION, values, filteredValues, "");
    144.         // is_visible_in_downloads_ui column
    145.         if (values.containsKey(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI)) {
    146.             copyBoolean(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI, values, filteredValues);
    147.         } else {
    148.             // by default, make external downloads visible in the UI
    149.             boolean isExternal = (dest == null || dest == Downloads.Impl.DESTINATION_EXTERNAL);
    150.             filteredValues.put(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI, isExternal);
    151.         }
    153.         // public api requests and networktypes/roaming columns
    154.         if (isPublicApi) {
    155.             copyInteger(Downloads.Impl.COLUMN_ALLOWED_NETWORK_TYPES, values, filteredValues);
    156.             copyBoolean(Downloads.Impl.COLUMN_ALLOW_ROAMING, values, filteredValues);
    157.             copyBoolean(Downloads.Impl.COLUMN_ALLOW_METERED, values, filteredValues);
    158.         }
    160.         if (Constants.LOGVV) {
    161.             Log.v(Constants.TAG, "initiating download with UID "
    162.                     + filteredValues.getAsInteger(Constants.UID));
    163.             if (filteredValues.containsKey(Downloads.Impl.COLUMN_OTHER_UID)) {
    164.                 Log.v(Constants.TAG, "other UID " +
    165.                         filteredValues.getAsInteger(Downloads.Impl.COLUMN_OTHER_UID));
    166.             }
    167.         }
    169.         //将数据插入到DB里面
    170.         long rowID = db.insert(DB_TABLE, null, filteredValues);
    171.         if (rowID == -1) {
    172.             Log.d(Constants.TAG, "couldn't insert into downloads database");
    173.             return null;
    174.         }
    176.         //将请求头数据插入到DB里面
    177.         insertRequestHeaders(db, rowID, values);
    178.         //通知有内容改变
    179.         notifyContentChanged(uri, match);
    181.         // Always start service to handle notifications and/or scanning
    182.         final Context context = getContext();
    183.         //启动DownloadService开始下载
    184.         context.startService(new Intent(context, DownloadService.class));
    186.         return ContentUris.withAppendedId(Downloads.Impl.CONTENT_URI, rowID);
    187.     }
    DownloadProvider里面的insert方法里面，会先检测相关权限，如果有权限，将表中的各列依次赋值，然后插入到数据库对应表中，然后启动DownloadService开始下载。

    c.)onStartCommand服务中开始下载任务
    文件位置packages/providers/com.android.providers.downloads/DownloadService.java
    1.     @Override
    2.     public int onStartCommand(Intent intent, int flags, int startId) {
    3.         int returnValue = super.onStartCommand(intent, flags, startId);
    4.         if (Constants.LOGVV) {
    5.             Log.v(Constants.TAG, "Service onStart");
    6.         }
    7.         mLastStartId = startId;
    8.         enqueueUpdate();
    9.         return returnValue;
    10.     }
    服务启动后执行enqueueUpdate，此方法会发送一个MSG_UPDATE消息，
    1.    private void enqueueUpdate() {
    2.         mUpdateHandler.removeMessages(MSG_UPDATE);
    3.         mUpdateHandler.obtainMessage(MSG_UPDATE, mLastStartId, -1).sendToTarget();
    4.     }
    此消息的处理是在
    1.     private Handler.Callback mUpdateCallback = new Handler.Callback() {
    2.         @Override
    3.         public boolean handleMessage(Message msg) {
    4.             Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    6.             final int startId = msg.arg1;
    7.             if (DEBUG_LIFECYCLE) Log.v(TAG, "Updating for startId " + startId);
    9.             // Since database is current source of truth, our "active" status
    10.             // depends on database state. We always get one final update pass
    11.             // once the real actions have finished and persisted their state.
    13.             // TODO: switch to asking real tasks to derive active state
    14.             // TODO: handle media scanner timeouts
    16.             final boolean isActive;
    17.             synchronized (mDownloads) {
    18.                 isActive = updateLocked();
    19.             }
    21.             if (msg.what == MSG_FINAL_UPDATE) {
    22.                 // Dump thread stacks belonging to pool
    23.                 for (Map.Entry<Thread, StackTraceElement[]> entry :
    24.                         Thread.getAllStackTraces().entrySet()) {
    25.                     if (entry.getKey().getName().startsWith("pool")) {
    26.                         Log.d(TAG, entry.getKey() + ": " + Arrays.toString(entry.getValue()));
    27.                     }
    28.                 }
    30.                 // Dump speed and update details
    31.                 mNotifier.dumpSpeeds();
    33.                 Log.wtf(TAG, "Final update pass triggered, isActive=" + isActive
    34.                         + "; someone didn't update correctly.");
    35.             }
    37.             if (isActive) {
    38.                 // Still doing useful work, keep service alive. These active
    39.                 // tasks will trigger another update pass when they're finished.
    41.                 // Enqueue delayed update pass to catch finished operations that
    42.                 // didn't trigger an update pass; these are bugs.
    43.                 enqueueFinalUpdate();
    45.             } else {
    46.                 // No active tasks, and any pending update messages can be
    47.                 // ignored, since any updates important enough to initiate tasks
    48.                 // will always be delivered with a new startId.
    50.                 if (stopSelfResult(startId)) {
    51.                     if (DEBUG_LIFECYCLE) Log.v(TAG, "Nothing left; stopped");
    52.                     getContentResolver().unregisterContentObserver(mObserver);
    53.                     mScanner.shutdown();
    54.                     mUpdateThread.quit();
    55.                 }
    56.             }
    58.             return true;
    59.         }
    60.     };
    看代码第18行，isActive = updateLocked();
    1.     private boolean updateLocked() {
    2.         final long now = mSystemFacade.currentTimeMillis();
    4.         boolean isActive = false;
    5.         long nextActionMillis = Long.MAX_VALUE;
    7.         final Set<Long> staleIds = Sets.newHashSet(mDownloads.keySet());
    9.         final ContentResolver resolver = getContentResolver();
    10.         final Cursor cursor = resolver.query(Downloads.Impl.ALL_DOWNLOADS_CONTENT_URI,
    11.                 null, null, null, null);
    12.         try {
    13.             //更新DB里面所有下载记录
    14.             final DownloadInfo.Reader reader = new DownloadInfo.Reader(resolver, cursor);
    15.             final int idColumn = cursor.getColumnIndexOrThrow(Downloads.Impl._ID);
    16.             while (cursor.moveToNext()) {
    17.                 final long id = cursor.getLong(idColumn);
    18.                 staleIds.remove(id);
    19.                 
    20.                 DownloadInfo info = mDownloads.get(id);
    21.                 //如果下载信息保存在mDownloads里面，则直接更新，由于我们是新添加的一个任务，info为空，走insertDownloadLocked这一步
    22.                 if (info != null) {
    23.                     updateDownload(reader, info, now);
    24.                 } else {
    25.                     //创建一个新的DownloadInfo，然后添加到mDownloads里面去
    26.                     info = insertDownloadLocked(reader, now);
    27.                 }
    29.                 if (info.mDeleted) {
    30.                     // Delete download if requested, but only after cleaning up
    31.                     if (!TextUtils.isEmpty(info.mMediaProviderUri)) {
    32.                         resolver.delete(Uri.parse(info.mMediaProviderUri), null, null);
    33.                     }
    35.                     deleteFileIfExists(info.mFileName);
    36.                     resolver.delete(info.getAllDownloadsUri(), null, null);
    38.                 } else {
    39.                     // Kick off download task if ready 准备开始下载
    40.                     final boolean activeDownload = info.startDownloadIfReady(mExecutor);
    42.                     // Kick off media scan if completed
    43.                     final boolean activeScan = info.startScanIfReady(mScanner);
    45.                     if (DEBUG_LIFECYCLE && (activeDownload || activeScan)) {
    46.                         Log.v(TAG, "Download " + info.mId + ": activeDownload=" + activeDownload
    47.                                 + ", activeScan=" + activeScan);
    48.                     }
    50.                     isActive |= activeDownload;
    51.                     isActive |= activeScan;
    52.                 }
    54.                 // Keep track of nearest next action
    55.                 nextActionMillis = Math.min(info.nextActionMillis(now), nextActionMillis);
    56.             }
    57.         } finally {
    58.             cursor.close();
    59.         }
    61.         // Clean up stale downloads that disappeared
    62.         for (Long id : staleIds) {
    63.             deleteDownloadLocked(id);
    64.         }
    66.         // Update notifications visible to user
    67.         mNotifier.updateWith(mDownloads.values());
    69.         // Set alarm when next action is in future. It's okay if the service
    70.         // continues to run in meantime, since it will kick off an update pass.
    71.         if (nextActionMillis > 0 && nextActionMillis < Long.MAX_VALUE) {
    72.             if (Constants.LOGV) {
    73.                 Log.v(TAG, "scheduling start in " + nextActionMillis + "ms");
    74.             }
    76.             final Intent intent = new Intent(Constants.ACTION_RETRY);
    77.             intent.setClass(this, DownloadReceiver.class);
    78.             mAlarmManager.set(AlarmManager.RTC_WAKEUP, now + nextActionMillis,
    79.                     PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_ONE_SHOT));
    80.         }
    82.         return isActive;
    83.     }
    此方法会更新DB里面的所有下载记录，先获取所有记录，然后依次更新。当我们新添加一条记录时，会新创建一个DownloadInfo对象，并添加到mDownloads集合里面；然后调用DownloadInfo的startDownloadIfReady方法

    d.) startDownloadIfReady 准备开始下载
    文件位置packages/providers/com.android.providers.downloads/DownloadInfo.java
    1. public boolean startDownloadIfReady(ExecutorService executor) {
    2.         synchronized (this) {
    3.             //判断是否可以下载，由于mControl为0，返回true
    4.             final boolean isReady = isReadyToDownload();
    5.             //判断是否有任务正在进行，对象是新创建的，mSubmittedTask 为空
    6.             final boolean isActive = mSubmittedTask != null && !mSubmittedTask.isDone();
    7.             if (isReady && !isActive) {
    8.                 //如果当前状态不是正在下载，将当前状态更新为正在下载
    9.                 if (mStatus != Impl.STATUS_RUNNING) {
    10.                     mStatus = Impl.STATUS_RUNNING;
    11.                     ContentValues values = new ContentValues();
    12.                     values.put(Impl.COLUMN_STATUS, mStatus);
    13.                     mContext.getContentResolver().update(getAllDownloadsUri(), values, null, null);
    14.                 }
    15.                 //开始下载任务
    16.                 mTask = new DownloadThread(
    17.                         mContext, mSystemFacade, this, mStorageManager, mNotifier);
    18.                 mSubmittedTask = executor.submit(mTask);
    19.             }
    20.             return isReady;
    21.         }
    22.     }
    此方法中，先判断当前状态是否可以下载，如果可以下载，则开始一个任务下载

    e.) DownloadThread的run方法
    文件位置packages/providers/com.android.providers.downloads/DownloadThread.java
    1.     @Override
    2.     public void run() {
    3.         Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    4.         try {
    5.             runInternal();
    6.         } finally {
    7.             mNotifier.notifyDownloadSpeed(mInfo.mId, 0);
    8.         }
    9.     }
    11.     private void runInternal() {
    12.         // Skip when download already marked as finished; this download was
    13.         // probably started again while racing with UpdateThread.
    14.         if (DownloadInfo.queryDownloadStatus(mContext.getContentResolver(), mInfo.mId)
    15.                 == Downloads.Impl.STATUS_SUCCESS) {
    16.             Log.d(TAG, "Download " + mInfo.mId + " already finished; skipping");
    17.             return;
    18.         }
    20.         State state = new State(mInfo);
    21.         PowerManager.WakeLock wakeLock = null;
    22.         int finalStatus = Downloads.Impl.STATUS_UNKNOWN_ERROR;
    23.         int numFailed = mInfo.mNumFailed;
    24.         String errorMsg = null;
    26.         final NetworkPolicyManager netPolicy = NetworkPolicyManager.from(mContext);
    27.         final PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
    29.         try {
    30.             wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, Constants.TAG);
    31.             wakeLock.setWorkSource(new WorkSource(mInfo.mUid));
    32.             wakeLock.acquire();
    34.             // while performing download, register for rules updates
    35.             netPolicy.registerListener(mPolicyListener);
    37.             Log.i(Constants.TAG, "Download " + mInfo.mId + " starting");
    39.             // Remember which network this download started on; used to
    40.             // determine if errors were due to network changes.
    41.             final NetworkInfo info = mSystemFacade.getActiveNetworkInfo(mInfo.mUid);
    42.             if (info != null) {
    43.                 state.mNetworkType = info.getType();
    44.             }
    46.             // Network traffic on this thread should be counted against the
    47.             // requesting UID, and is tagged with well-known value.
    48.             TrafficStats.setThreadStatsTag(TrafficStats.TAG_SYSTEM_DOWNLOAD);
    49.             TrafficStats.setThreadStatsUid(mInfo.mUid);
    51.             try {
    52.                 // TODO: migrate URL sanity checking into client side of API
    53.                 state.mUrl = new URL(state.mRequestUri);
    54.             } catch (MalformedURLException e) {
    55.                 throw new StopRequestException(STATUS_BAD_REQUEST, e);
    56.             }
    57.             //执行下载
    58.             executeDownload(state);
    60.             finalizeDestinationFile(state);
    61.             finalStatus = Downloads.Impl.STATUS_SUCCESS;
    62.         } catch (StopRequestException error) {
    63.             // remove the cause before printing, in case it contains PII
    64.             errorMsg = error.getMessage();
    65.             String msg = "Aborting request for download " + mInfo.mId + ": " + errorMsg;
    66.             Log.w(Constants.TAG, msg);
    67.             if (Constants.LOGV) {
    68.                 Log.w(Constants.TAG, msg, error);
    69.             }
    70.             finalStatus = error.getFinalStatus();
    72.             // Nobody below our level should request retries, since we handle
    73.             // failure counts at this level.
    74.             if (finalStatus == STATUS_WAITING_TO_RETRY) {
    75.                 throw new IllegalStateException("Execution should always throw final error codes");
    76.             }
    78.             // Some errors should be retryable, unless we fail too many times.
    79.             if (isStatusRetryable(finalStatus)) {
    80.                 if (state.mGotData) {
    81.                     numFailed = 1;
    82.                 } else {
    83.                     numFailed += 1;
    84.                 }
    86.                 if (numFailed < Constants.MAX_RETRIES) {
    87.                     final NetworkInfo info = mSystemFacade.getActiveNetworkInfo(mInfo.mUid);
    88.                     if (info != null && info.getType() == state.mNetworkType
    89.                             && info.isConnected()) {
    90.                         // Underlying network is still intact, use normal backoff
    91.                         finalStatus = STATUS_WAITING_TO_RETRY;
    92.                     } else {
    93.                         // Network changed, retry on any next available
    94.                         finalStatus = STATUS_WAITING_FOR_NETWORK;
    95.                     }
    96.                 }
    97.             }
    99.             // fall through to finally block
    100.         } catch (Throwable ex) {
    101.             errorMsg = ex.getMessage();
    102.             String msg = "Exception for id " + mInfo.mId + ": " + errorMsg;
    103.             Log.w(Constants.TAG, msg, ex);
    104.             finalStatus = Downloads.Impl.STATUS_UNKNOWN_ERROR;
    105.             // falls through to the code that reports an error
    106.         } finally {
    107.             if (finalStatus == STATUS_SUCCESS) {
    108.                 TrafficStats.incrementOperationCount(1);
    109.             }
    111.             TrafficStats.clearThreadStatsTag();
    112.             TrafficStats.clearThreadStatsUid();
    114.             cleanupDestination(state, finalStatus);
    115.             notifyDownloadCompleted(state, finalStatus, errorMsg, numFailed);
    117.             Log.i(Constants.TAG, "Download " + mInfo.mId + " finished with status "
    118.                     + Downloads.Impl.statusToString(finalStatus));
    120.             netPolicy.unregisterListener(mPolicyListener);
    122.             if (wakeLock != null) {
    123.                 wakeLock.release();
    124.                 wakeLock = null;
    125.             }
    126.         }
    127.         mStorageManager.incrementNumDownloadsSoFar();
    128.     }
    启动任务，里面会调用runInternal，这个里面的逻辑很复杂，我们只关注executeDownload方法
    1.    /**
    2.      * Fully execute a single download request. Setup and send the request,
    3.      * handle the response, and transfer the data to the destination file.
    4.      */
    5.     private void executeDownload(State state) throws StopRequestException {
    6.         state.resetBeforeExecute();
    7.         //设置下载文件相关信息，文件是否存在、是否从0开始下载还是接着下载
    8.         setupDestinationFile(state);
    10.         // skip when already finished; remove after fixing race in 5217390
    11.         if (state.mCurrentBytes == state.mTotalBytes) {
    12.             Log.i(Constants.TAG, "Skipping initiating request for download " +
    13.                   mInfo.mId + "; already completed");
    14.             return;
    15.         }
    17.         while (state.mRedirectionCount++ < Constants.MAX_REDIRECTS) {
    18.             // Open connection and follow any redirects until we have a useful
    19.             // response with body.
    20.             HttpURLConnection conn = null;
    21.             try {
    22.                 checkConnectivity();
    23.                 conn = (HttpURLConnection) state.mUrl.openConnection();
    24.                 conn.setInstanceFollowRedirects(false);
    25.                 conn.setConnectTimeout(DEFAULT_TIMEOUT);
    26.                 conn.setReadTimeout(DEFAULT_TIMEOUT);
    28.                 addRequestHeaders(state, conn);
    30.                 final int responseCode = conn.getResponseCode();
    31.                 switch (responseCode) {
    32.                     case HTTP_OK:
    33.                         if (state.mContinuingDownload) {
    34.                             throw new StopRequestException(
    35.                                     STATUS_CANNOT_RESUME, "Expected partial, but received OK");
    36.                         }
    37.                         processResponseHeaders(state, conn);
    38.                         transferData(state, conn);
    39.                         return;
    41.                     case HTTP_PARTIAL:
    42.                         if (!state.mContinuingDownload) {
    43.                             throw new StopRequestException(
    44.                                     STATUS_CANNOT_RESUME, "Expected OK, but received partial");
    45.                         }
    46.                         transferData(state, conn);
    47.                         return;
    49.                     case HTTP_MOVED_PERM:
    50.                     case HTTP_MOVED_TEMP:
    51.                     case HTTP_SEE_OTHER:
    52.                     case HTTP_TEMP_REDIRECT:
    53.                         final String location = conn.getHeaderField("Location");
    54.                         state.mUrl = new URL(state.mUrl, location);
    55.                         if (responseCode == HTTP_MOVED_PERM) {
    56.                             // Push updated URL back to database
    57.                             state.mRequestUri = state.mUrl.toString();
    58.                         }
    59.                         continue;
    61.                     case HTTP_REQUESTED_RANGE_NOT_SATISFIABLE:
    62.                         throw new StopRequestException(
    63.                                 STATUS_CANNOT_RESUME, "Requested range not satisfiable");
    65.                     case HTTP_UNAVAILABLE:
    66.                         parseRetryAfterHeaders(state, conn);
    67.                         throw new StopRequestException(
    68.                                 HTTP_UNAVAILABLE, conn.getResponseMessage());
    70.                     case HTTP_INTERNAL_ERROR:
    71.                         throw new StopRequestException(
    72.                                 HTTP_INTERNAL_ERROR, conn.getResponseMessage());
    74.                     default:
    75.                         StopRequestException.throwUnhandledHttpError(
    76.                                 responseCode, conn.getResponseMessage());
    77.                 }
    78.             } catch (IOException e) {
    79.                 // Trouble with low-level sockets
    80.                 throw new StopRequestException(STATUS_HTTP_DATA_ERROR, e);
    82.             } finally {
    83.                 if (conn != null) conn.disconnect();
    84.             }
    85.         }
    87.         throw new StopRequestException(STATUS_TOO_MANY_REDIRECTS, "Too many redirects");
    88.     }
    addRequestHeaders方法里面也有一些比较重要的东西
    1.     private void addRequestHeaders(State state, HttpURLConnection conn) {
    2.         for (Pair<String, String> header : mInfo.getHeaders()) {
    3.             conn.addRequestProperty(header.first, header.second);
    4.         }
    6.         // Only splice in user agent when not already defined
    7.         if (conn.getRequestProperty("User-Agent") == null) {
    8.             conn.addRequestProperty("User-Agent", userAgent());
    9.         }
    11.         // Defeat transparent gzip compression, since it doesn't allow us to
    12.         // easily resume partial downloads.
    13.         conn.setRequestProperty("Accept-Encoding", "identity");
    15.         if (state.mContinuingDownload) {
    16.             if (state.mHeaderETag != null) {
    17.                 conn.addRequestProperty("If-Match", state.mHeaderETag);
    18.             }
    19.             conn.addRequestProperty("Range", "bytes=" + state.mCurrentBytes + "-");
    20.         }
    21.     }
    如果是继续下载，则把当前的下载进度放在请求头里面。

    2.2 系统广播启动下载
    在packages/providers/com.android.providers.downloads/DownloadReceiver.java文件里面
    1.      public void onReceive(final Context context, final Intent intent) {
    2.         if (mSystemFacade == null) {
    3.             mSystemFacade = new RealSystemFacade(context);
    4.         }
    6.         String action = intent.getAction();
    7.         if (action.equals(Intent.ACTION_BOOT_COMPLETED)) {
    8.             if (Constants.LOGVV) {
    9.                 Log.v(Constants.TAG, "Received broadcast intent for " +
    10.                         Intent.ACTION_BOOT_COMPLETED);
    11.             }
    12.             startService(context);
    13.         } else if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) {
    14.             if (Constants.LOGVV) {
    15.                 Log.v(Constants.TAG, "Received broadcast intent for " +
    16.                         Intent.ACTION_MEDIA_MOUNTED);
    17.             }
    18.             startService(context);
    19.         } else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
    20.             final ConnectivityManager connManager = (ConnectivityManager) context
    21.                     .getSystemService(Context.CONNECTIVITY_SERVICE);
    22.             final NetworkInfo info = connManager.getActiveNetworkInfo();
    23.             if (info != null && info.isConnected()) {
    24.                 startService(context);
    25.             }
    26.         } else if (action.equals(Constants.ACTION_RETRY)) {
    27.             startService(context);
    28.         } else if (action.equals(Constants.ACTION_OPEN)
    29.                 || action.equals(Constants.ACTION_LIST)
    30.                 || action.equals(Constants.ACTION_HIDE)) {
    32.             final PendingResult result = goAsync();
    33.             if (result == null) {
    34.                 // TODO: remove this once test is refactored
    35.                 handleNotificationBroadcast(context, intent);
    36.             } else {
    37.                 sAsyncHandler.post(new Runnable() {
    38.                     @Override
    39.                     public void run() {
    40.                         handleNotificationBroadcast(context, intent);
    41.                         result.finish();
    42.                     }
    43.                 });
    44.             }
    45.         }
    46.     }


    注意：
           当service第一次被启动时会调用onCreate()方法, 然后再调用onStartCommand()方法. 在该service的生命周期内, 如果再次启动这个service, 就会直接调用onStartCommand()方法了.


            
  • 相关阅读:
    Log4j学习
    HttpURLConnection请求
    正则表达式验证中文、图片上传
    freemarker学习
    参数中带有“&”符号问题
    禁止打印页面
    myEclipse 界面窗口打不开问题
    屏蔽网页右键
    分享功能
    table表格某一td内容太多导致样式混乱的解决方案
  • 原文地址：https://www.cnblogs.com/adm1989/p/4631129.html
Copyright © 2011-2022 走看看