import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public void unbindByContext(final Context context) {
    if (!BIND_CONTEXTS.contains(context)) {
        return;
    }

    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "unbindByContext %s", context);
    }

    BIND_CONTEXTS.remove(context);


    if (BIND_CONTEXTS.isEmpty()) {
        releaseConnect(false);
    }

    Intent i = new Intent(context, serviceClass);
    context.unbindService(this);
    context.stopService(i);
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
private boolean onAssembledTasksToStart(int attachKey, final List<BaseDownloadTask.IRunningTask> list,
                                        final FileDownloadListener listener, boolean isSerial) {
    if (FileDownloadMonitor.isValid()) {
        FileDownloadMonitor.getMonitor().onRequestStart(list.size(), true, listener);
    }

    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.v(FileDownloader.class, "start list attachKey[%d] size[%d] " +
                "listener[%s] isSerial[%B]", attachKey, list.size(), listener, isSerial);
    }

    if (list == null || list.isEmpty()) {
        FileDownloadLog.w(FileDownloader.class, "Tasks with the listener can't start, " +
                        "because can't find any task with the provided listener, maybe tasks " +
                        "instance has been started in the past, so they are all are inUsing, if " +
                        "in this case, you can use [BaseDownloadTask#reuse] to reuse theme " +
                        "first then start again: [%s, %B]",
                listener, isSerial);

        return true;
    }

    return false;

}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public void onRetry(Exception exception, long invalidIncreaseBytes) {
    if (paused) {
        if (FileDownloadLog.NEED_LOG) {
            FileDownloadLog.d(this, "the task[%d] has already been paused, so pass the" +
                    " retry callback", model.getId());
        }
        return;
    }

    if (validRetryTimes-- < 0) {
        FileDownloadLog.e(this, "valid retry times is less than 0(%d) for download task(%d)",
                validRetryTimes, model.getId());
    }

    statusCallback.onRetry(exception, validRetryTimes--, invalidIncreaseBytes);
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
private void sync() {
    final long startTimestamp = SystemClock.uptimeMillis();
    try {
        outputStream.sync();
    } catch (IOException e) {
        e.printStackTrace();
    }

    final boolean isBelongMultiConnection = hostRunnable != null;
    if (isBelongMultiConnection) {
        // only need update the connection table.
        database.updateConnectionModel(downloadId, connectionIndex, currentOffset);
    } else {
        // only need update the filedownloader table.
        callback.syncProgressFromCache();
    }

    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "require sync id[%d] index[%d] offset[%d], consume[%d]",
                downloadId, connectionIndex, currentOffset, SystemClock.uptimeMillis() - startTimestamp);
    }
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
FileDownloadConnection connect() throws IOException, IllegalAccessException {
    FileDownloadConnection connection = CustomComponentHolder.getImpl().createConnection(url);

    addUserRequiredHeader(connection);
    addRangeHeader(connection);

    // init request
    // get the request header in here, because of there are many connection
    // component(such as HttpsURLConnectionImpl, HttpURLConnectionImpl in okhttp3) don't
    // allow access to the request header after it connected.
    requestHeader = connection.getRequestHeaderFields();
    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "%s request header %s", downloadId, requestHeader);
    }

    connection.execute();
    redirectedUrlList = new ArrayList<>();
    connection = RedirectHandler.process(requestHeader, connection, redirectedUrlList);

    return connection;
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
private void onStatusChanged(final byte status) {
    // In current situation, it maybe invoke this method simultaneously between #onPause() and
    // others.
    if (model.getStatus() == FileDownloadStatus.paused) {
        if (FileDownloadLog.NEED_LOG) {
            /**
             * Already paused or the current status is paused.
             *
             * We don't need to call-back to Task in here, because the pause status has
             * already handled by {@link BaseDownloadTask#pause()} manually.
             *
             * In some case, it will arrive here by High concurrent cause.  For performance
             * more make sense.
             *
             * High concurrent cause.
             */
            FileDownloadLog.d(this, "High concurrent cause, Already paused and we don't " +
                    "need to call-back to Task in here, %d", model.getId());
        }
        return;
    }

    MessageSnapshotFlow.getImpl().inflow(MessageSnapshotTaker.take(status, model, processParams));
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
public synchronized boolean setMaxNetworkThreadCount(int count) {
    if (exactSize() > 0) {
        FileDownloadLog.w(this, "Can't change the max network thread count, because the " +
                " network thread pool isn't in IDLE, please try again after all running" +
                " tasks are completed or invoking FileDownloader#pauseAll directly.");
        return false;
    }

    final int validCount = FileDownloadProperties.getValidNetworkThreadCount(count);

    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "change the max network thread count, from %d to %d",
                mMaxThreadCount, validCount);
    }

    final List<Runnable> taskQueue = mThreadPool.shutdownNow();
    mThreadPool = FileDownloadExecutors.newDefaultThreadPool(validCount, THREAD_PREFIX);

    if (taskQueue.size() > 0) {
        FileDownloadLog.w(this, "recreate the network thread pool and discard %d tasks",
                taskQueue.size());
    }

    mMaxThreadCount = validCount;
    return true;
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    this.service = asInterface(service);

    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "onServiceConnected %s %s", name, this.service);
    }

    try {
        registerCallback(this.service, this.callback);
    } catch (RemoteException e) {
        e.printStackTrace();
    }

    @SuppressWarnings("unchecked") final List<Runnable> runnableList =
            (List<Runnable>) connectedRunnableList.clone();
    connectedRunnableList.clear();
    for (Runnable runnable : runnableList) {
        runnable.run();
    }

    FileDownloadEventPool.getImpl().
            asyncPublishInNewThread(new DownloadServiceConnectChangedEvent(
                    DownloadServiceConnectChangedEvent.ConnectStatus.connected, serviceClass));

}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
private void releaseConnect(final boolean isLost) {
    if (!isLost && this.service != null) {
        try {
            unregisterCallback(this.service, this.callback);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "release connect resources %s", this.service);
    }
    this.service = null;

    FileDownloadEventPool.getImpl().
            asyncPublishInNewThread(new DownloadServiceConnectChangedEvent(
                    isLost ? DownloadServiceConnectChangedEvent.ConnectStatus.lost :
                            DownloadServiceConnectChangedEvent.ConnectStatus.disconnected,
                    serviceClass));
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public void update(FileDownloadModel downloadModel) {
    if (downloadModel == null) {
        FileDownloadLog.w(this, "update but model == null!");
        return;
    }

    if (find(downloadModel.getId()) != null) {
        // 替换
        downloaderModelMap.remove(downloadModel.getId());
        downloaderModelMap.put(downloadModel.getId(), downloadModel);

        // db
        ContentValues cv = downloadModel.toContentValues();
        db.update(TABLE_NAME, cv, FileDownloadModel.ID + " = ? ", new String[]{String.valueOf(downloadModel.getId())});
    } else {
        insert(downloadModel);
    }
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
public int getMaxNetworkThreadCount() {
    if (mMaker == null) {
        return getDefaultMaxNetworkThreadCount();
    }

    final Integer customizeMaxNetworkThreadCount = mMaker.mMaxNetworkThreadCount;

    if (customizeMaxNetworkThreadCount != null) {
        if (FileDownloadLog.NEED_LOG) {
            FileDownloadLog.d(this, "initial FileDownloader manager with the customize " +
                    "maxNetworkThreadCount: %d", customizeMaxNetworkThreadCount);
        }

        return FileDownloadProperties.getValidNetworkThreadCount(customizeMaxNetworkThreadCount);
    } else {
        return getDefaultMaxNetworkThreadCount();
    }

}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
public FileDownloadDatabase createDatabase() {
    if (mMaker == null || mMaker.mDatabaseCustomMaker == null) {
        return createDefaultDatabase();
    }
    final FileDownloadDatabase customDatabase = mMaker.mDatabaseCustomMaker.customMake();

    if (customDatabase != null) {
        if (FileDownloadLog.NEED_LOG) {
            FileDownloadLog.d(this, "initial FileDownloader manager with the customize " +
                    "database: %s", customDatabase);
        }
        return customDatabase;
    } else {
        return createDefaultDatabase();
    }
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
public FileDownloadHelper.ConnectionCountAdapter createConnectionCountAdapter() {
    if (mMaker == null) {
        return createDefaultConnectionCountAdapter();
    }

    final FileDownloadHelper.ConnectionCountAdapter adapter = mMaker.mConnectionCountAdapter;
    if (adapter != null) {
        if (FileDownloadLog.NEED_LOG) {
            FileDownloadLog.d(this, "initial FileDownloader manager with the customize " +
                    "connection count adapter: %s", adapter);
        }
        return adapter;
    } else {
        return createDefaultConnectionCountAdapter();
    }
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
public FileDownloadHelper.IdGenerator createIdGenerator() {
    if (mMaker == null) {
        return createDefaultIdGenerator();
    }

    final FileDownloadHelper.IdGenerator idGenerator = mMaker.mIdGenerator;
    if (idGenerator != null) {
        if (FileDownloadLog.NEED_LOG) {
            FileDownloadLog.d(this, "initial FileDownloader manager with the customize " +
                    "id generator: %s", idGenerator);
        }

        return idGenerator;
    } else {
        return createDefaultIdGenerator();
    }
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public boolean publish(final IDownloadEvent event) {
    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.v(this, "publish %s", event.getId());
    }
    Assert.assertNotNull("EventPoolImpl.publish", event);
    String eventId = event.getId();
    LinkedList<IDownloadListener> listeners = listenersMap.get(eventId);
    if (listeners == null) {
        synchronized (eventId.intern()) {
            listeners = listenersMap.get(eventId);
            if (listeners == null) {
                if (FileDownloadLog.NEED_LOG) {
                    FileDownloadLog.d(this, "No listener for this event %s", eventId);
                }
                return false;
            }
        }
    }

    trigger(listeners, event);
    return true;
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
/**
 * This method generally used for enqueuing the task which will be assembled by a queue.
 *
 * @see BaseDownloadTask.InQueueTask#enqueue()
 */
void addUnchecked(final BaseDownloadTask.IRunningTask task) {
    if (task.isMarkedAdded2List()) {
        return;
    }

    synchronized (mList) {
        if (mList.contains(task)) {
            FileDownloadLog.w(this, "already has %s", task);
        } else {
            task.markAdded2List();
            mList.add(task);
            if (FileDownloadLog.NEED_LOG) {
                FileDownloadLog.v(this, "add list in all %s %d %d", task,
                        task.getOrigin().getStatus(), mList.size());
            }
        }
    }
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public boolean notifyBegin() {
    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "notify begin %s", mTask);
    }

    if (mTask == null) {
        FileDownloadLog.w(this, "can't begin the task, the holder fo the messenger is nil, %d",
                parcelQueue.size());
        return false;
    }

    mLifeCycleCallback.onBegin();

    return true;
}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public void notifyProgress(MessageSnapshot snapshot) {
    final BaseDownloadTask originTask = mTask.getOrigin();
    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.d(this, "notify progress %s %d %d",
                originTask, originTask.getLargeFileSoFarBytes(), originTask.getLargeFileTotalBytes());
    }
    if (originTask.getCallbackProgressTimes() <= 0) {
        if (FileDownloadLog.NEED_LOG) {
            FileDownloadLog.d(this, "notify progress but client not request notify %s", mTask);
        }
        return;
    }

    mLifeCycleCallback.onIng();

    process(snapshot);

}
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
private synchronized void sendMessage(Message message) {

        if (!handlerThread.isAlive()) {
            if (FileDownloadLog.NEED_LOG) {
                FileDownloadLog.d(this, ALREADY_DEAD_MESSAGE, message.what);
            }
            return;
        }

        try {
            handler.sendMessage(message);
        } catch (IllegalStateException e) {
            if (!handlerThread.isAlive()) {
                if (FileDownloadLog.NEED_LOG) {
                    FileDownloadLog.d(this, ALREADY_DEAD_MESSAGE, message.what);
                }
            } else {
                // unknown error
                throw e;
            }
        }
    }
 

import com.liulishuo.filedownloader.util.FileDownloadLog; //导入依赖的package包/类
@Override
public void onOver() {
    final BaseDownloadTask origin = mTask.getRunningTask().getOrigin();

    if (FileDownloadMonitor.isValid()) {
        FileDownloadMonitor.getMonitor().onTaskOver(origin);
    }

    if (FileDownloadLog.NEED_LOG) {
        FileDownloadLog.v(this, "filedownloader:lifecycle:over %s by %d ", toString(),
                getStatus());
    }

    mSpeedMonitor.end(this.mSoFarBytes);
    if (mTask.getFinishListenerList() != null) {
        @SuppressWarnings("unchecked") final ArrayList<BaseDownloadTask.FinishListener>
                listenersCopy =
                (ArrayList<BaseDownloadTask.FinishListener>) mTask.getFinishListenerList().clone();
        final int numListeners = listenersCopy.size();
        for (int i = 0; i < numListeners; ++i) {
            listenersCopy.get(i).over(origin);
        }
    }

    FileDownloader.getImpl().getLostConnectedHandler().taskWorkFine(mTask.getRunningTask());
}