优化target代码

v3.6.6
laoyuyu 6 years ago
parent 598c863559
commit 30c41e4cb2
  1. 308
      Aria/src/main/java/com/arialyy/aria/core/Aria.java
  2. 244
      Aria/src/main/java/com/arialyy/aria/core/common/ftp/FTPSDelegate.java
  3. 124
      Aria/src/main/java/com/arialyy/aria/core/common/ftp/FtpTaskDelegate.java
  4. 204
      Aria/src/main/java/com/arialyy/aria/core/common/http/HttpDelegate.java
  5. 374
      Aria/src/main/java/com/arialyy/aria/core/common/http/HttpTaskDelegate.java
  6. 223
      Aria/src/main/java/com/arialyy/aria/core/download/AbsDownloadTarget.java
  7. 7
      Aria/src/main/java/com/arialyy/aria/core/download/BaseGroupTarget.java
  8. 406
      Aria/src/main/java/com/arialyy/aria/core/download/BaseNormalTarget.java
  9. 161
      Aria/src/main/java/com/arialyy/aria/core/download/DNormalDelegate.java
  10. 674
      Aria/src/main/java/com/arialyy/aria/core/download/DownloadGroupTarget.java
  11. 302
      Aria/src/main/java/com/arialyy/aria/core/download/DownloadTarget.java
  12. 290
      Aria/src/main/java/com/arialyy/aria/core/download/FtpDirDownloadTarget.java
  13. 282
      Aria/src/main/java/com/arialyy/aria/core/download/FtpDownloadTarget.java
  14. 660
      Aria/src/main/java/com/arialyy/aria/core/inf/AbsTarget.java
  15. 114
      Aria/src/main/java/com/arialyy/aria/core/inf/IFtpTarget.java
  16. 102
      Aria/src/main/java/com/arialyy/aria/core/inf/IHttpHeaderDelegate.java
  17. 141
      Aria/src/main/java/com/arialyy/aria/core/inf/ITargetHandler.java
  18. 47
      Aria/src/main/java/com/arialyy/aria/core/inf/ITargetHeadDelegate.java
  19. 81
      Aria/src/main/java/com/arialyy/aria/core/inf/ITargetNormal.java
  20. 261
      Aria/src/main/java/com/arialyy/aria/core/inf/ITask.java
  21. 75
      Aria/src/main/java/com/arialyy/aria/core/upload/AbsUploadTarget.java
  22. 292
      Aria/src/main/java/com/arialyy/aria/core/upload/BaseNormalTarget.java
  23. 227
      Aria/src/main/java/com/arialyy/aria/core/upload/FtpUploadTarget.java
  24. 132
      Aria/src/main/java/com/arialyy/aria/core/upload/UNormalDelegate.java
  25. 225
      Aria/src/main/java/com/arialyy/aria/core/upload/UploadTarget.java
  26. 488
      app/src/main/java/com/arialyy/simple/core/download/HighestPriorityActivity.java
  27. 2
      app/src/main/java/com/arialyy/simple/core/upload/HttpUploadActivity.java

@ -1,154 +1,154 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core; package com.arialyy.aria.core;
import android.annotation.TargetApi; import android.annotation.TargetApi;
import android.app.Activity; import android.app.Activity;
import android.app.Application; import android.app.Application;
import android.app.Dialog; import android.app.Dialog;
import android.app.Service; import android.app.Service;
import android.content.Context; import android.content.Context;
import android.os.Build; import android.os.Build;
import android.support.v4.app.DialogFragment; import android.support.v4.app.DialogFragment;
import android.support.v4.app.Fragment; import android.support.v4.app.Fragment;
import android.widget.PopupWindow; import android.widget.PopupWindow;
import com.arialyy.aria.core.download.DownloadReceiver; import com.arialyy.aria.core.download.DownloadReceiver;
import com.arialyy.aria.core.upload.UploadReceiver; import com.arialyy.aria.core.upload.UploadReceiver;
import com.arialyy.aria.util.ALog; import com.arialyy.aria.util.ALog;
/** /**
* Created by lyy on 2016/12/1. * Created by lyy on 2016/12/1.
* *
* @see <a href="https://github.com/AriaLyy/Aria">Aria</a> * @see <a href="https://github.com/AriaLyy/Aria">Aria</a>
* @see <a href="https://aria.laoyuyu.me/aria_doc/">Aria doc</a> * @see <a href="https://aria.laoyuyu.me/aria_doc/">Aria doc</a>
* Aria启动管理全局任务 * Aria启动管理全局任务
* <pre> * <pre>
* <code> * <code>
* //下载 * //下载
* Aria.download(this) * Aria.download(this)
* .load(URL) //下载地址,必填 * .load(URL) //下载地址,必填
* //文件保存路径,必填 * //文件保存路径,必填
* .setDownloadPath(Environment.getExternalStorageDirectory().getPath() + "/test.apk") * .setDownloadPath(Environment.getExternalStorageDirectory().getPath() + "/test.apk")
* .start(); * .start();
* </code> * </code>
* <code> * <code>
* //上传 * //上传
* Aria.upload(this) * Aria.upload(this)
* .load(filePath) //文件路径,必填 * .load(filePath) //文件路径,必填
* .setUploadUrl(uploadUrl) //上传路径,必填 * .setTempUrl(uploadUrl) //上传路径,必填
* .setAttachment(fileKey) //服务器读取文件的key,必填 * .setAttachment(fileKey) //服务器读取文件的key,必填
* .start(); * .start();
* </code> * </code>
* </pre> * </pre>
* *
* 如果你需要在ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog * 如果你需要在ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog
* 之外的java中使用Aria那么你应该在Application或Activity初始化的时候调用{@link #init(Context)}对Aria进行初始化 * 之外的java中使用Aria那么你应该在Application或Activity初始化的时候调用{@link #init(Context)}对Aria进行初始化
* 然后才能使用{@link #download(Object)}{@link #upload(Object)} * 然后才能使用{@link #download(Object)}{@link #upload(Object)}
* *
* <pre> * <pre>
* <code> * <code>
* Aria.init(this); * Aria.init(this);
* *
* Aria.download(this) * Aria.download(this)
* .load(URL) //下载地址,必填 * .load(URL) //下载地址,必填
* //文件保存路径,必填 * //文件保存路径,必填
* .setDownloadPath(Environment.getExternalStorageDirectory().getPath() + "/test.apk") * .setDownloadPath(Environment.getExternalStorageDirectory().getPath() + "/test.apk")
* .start(); * .start();
* *
* </code> * </code>
* *
* </pre> * </pre>
*/ */
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) public class Aria { @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) public class Aria {
private Aria() { private Aria() {
} }
/** /**
* 下载在当前类中调用Aria方法参数需要使用this否则将 * 下载在当前类中调用Aria方法参数需要使用this否则将
* 如果不是ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog对象那么你 * 如果不是ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog对象那么你
* 需要在对象中初始化下载前在Application或Activity初始化的时候调用{@link #init(Context)}对Aria进行初始化 * 需要在对象中初始化下载前在Application或Activity初始化的时候调用{@link #init(Context)}对Aria进行初始化
* *
* @param obj 观察者对象为本类对象使用{@code this} * @param obj 观察者对象为本类对象使用{@code this}
*/ */
public static DownloadReceiver download(Object obj) { public static DownloadReceiver download(Object obj) {
if (AriaManager.getInstance() != null){ if (AriaManager.getInstance() != null){
return AriaManager.getInstance().download(obj); return AriaManager.getInstance().download(obj);
} }
return get(convertContext(obj)).download(obj); return get(convertContext(obj)).download(obj);
} }
/** /**
* 上传 * 上传
* 如果不是ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog对象那么你 * 如果不是ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog对象那么你
* 需要在对象中初始化下载前在Application或Activity初始化的时候调用{@link #init(Context)}对Aria进行初始化 * 需要在对象中初始化下载前在Application或Activity初始化的时候调用{@link #init(Context)}对Aria进行初始化
* *
* @param obj 观察者对象为本类对象使用{@code this} * @param obj 观察者对象为本类对象使用{@code this}
*/ */
public static UploadReceiver upload(Object obj) { public static UploadReceiver upload(Object obj) {
if (AriaManager.getInstance() != null){ if (AriaManager.getInstance() != null){
return AriaManager.getInstance().upload(obj); return AriaManager.getInstance().upload(obj);
} }
return get(convertContext(obj)).upload(obj); return get(convertContext(obj)).upload(obj);
} }
/** /**
* 处理通用事件 * 处理通用事件
*/ */
public static AriaManager get(Context context) { public static AriaManager get(Context context) {
if (context == null) { if (context == null) {
throw new NullPointerException("context 无效,在非【Activity、Service、Application、DialogFragment、Fragment、PopupWindow、Dialog】," throw new NullPointerException("context 无效,在非【Activity、Service、Application、DialogFragment、Fragment、PopupWindow、Dialog】,"
+ "请参考【https://aria.laoyuyu.me/aria_doc/start/any_java.html】,参数请使用 download(this) 或 upload(this);" + "请参考【https://aria.laoyuyu.me/aria_doc/start/any_java.html】,参数请使用 download(this) 或 upload(this);"
+ "不要使用 download(getContext()) 或 upload(getContext())"); + "不要使用 download(getContext()) 或 upload(getContext())");
} }
return AriaManager.getInstance(context); return AriaManager.getInstance(context);
} }
/** /**
* 初始化Aria如果你需要在ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog * 初始化Aria如果你需要在ActivityServiceApplicationDialogFragmentFragmentPopupWindowDialog
* 之外的java中使用Aria那么你应该在Application或Activity初始化的时候调用本方法对Aria进行初始化 * 之外的java中使用Aria那么你应该在Application或Activity初始化的时候调用本方法对Aria进行初始化
* 只需要初始化一次就可以 * 只需要初始化一次就可以
* {@link #download(Object)}{@link #upload(Object)} * {@link #download(Object)}{@link #upload(Object)}
*/ */
public static AriaManager init(Context context) { public static AriaManager init(Context context) {
return AriaManager.getInstance(context); return AriaManager.getInstance(context);
} }
private static Context convertContext(Object obj) { private static Context convertContext(Object obj) {
if (obj instanceof Application) { if (obj instanceof Application) {
return (Application) obj; return (Application) obj;
} else if (obj instanceof Service) { } else if (obj instanceof Service) {
return (Service) obj; return (Service) obj;
} else if (obj instanceof Activity) { } else if (obj instanceof Activity) {
return (Activity) obj; return (Activity) obj;
} else if (obj instanceof DialogFragment) { } else if (obj instanceof DialogFragment) {
return ((DialogFragment) obj).getContext(); return ((DialogFragment) obj).getContext();
} else if (obj instanceof android.app.DialogFragment) { } else if (obj instanceof android.app.DialogFragment) {
return ((android.app.DialogFragment) obj).getActivity(); return ((android.app.DialogFragment) obj).getActivity();
} else if (obj instanceof android.support.v4.app.Fragment) { } else if (obj instanceof android.support.v4.app.Fragment) {
return ((Fragment) obj).getContext(); return ((Fragment) obj).getContext();
} else if (obj instanceof android.app.Fragment) { } else if (obj instanceof android.app.Fragment) {
return ((android.app.Fragment) obj).getActivity(); return ((android.app.Fragment) obj).getActivity();
} else if (obj instanceof Dialog) { } else if (obj instanceof Dialog) {
return ((Dialog) obj).getContext(); return ((Dialog) obj).getContext();
} else if (obj instanceof PopupWindow) { } else if (obj instanceof PopupWindow) {
return ((PopupWindow) obj).getContentView().getContext(); return ((PopupWindow) obj).getContentView().getContext();
} }
ALog.e("Aria", "请使用download(this)或upload(this)"); ALog.e("Aria", "请使用download(this)或upload(this)");
return null; return null;
} }
} }

@ -1,120 +1,124 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.common.ftp; package com.arialyy.aria.core.common.ftp;
import android.text.TextUtils; import android.text.TextUtils;
import com.arialyy.aria.core.FtpUrlEntity; import com.arialyy.aria.core.FtpUrlEntity;
import com.arialyy.aria.core.common.ProtocolType; import com.arialyy.aria.core.common.ProtocolType;
import com.arialyy.aria.core.inf.AbsTarget; import com.arialyy.aria.core.inf.AbsTarget;
import com.arialyy.aria.core.inf.ITarget; import com.arialyy.aria.core.inf.ITargetHandler;
/** /**
* FTP SSL/TSL 参数委托 * FTP SSL/TSL 参数委托
*/ */
public class FTPSDelegate<TARGET extends AbsTarget> implements ITarget { public class FTPSDelegate<TARGET extends AbsTarget> implements ITargetHandler {
private final String TAG = "FTPSDelegate"; private final String TAG = "FTPSDelegate";
private TARGET mTarget; private TARGET mTarget;
private FtpUrlEntity mUrlEntity; private FtpUrlEntity mUrlEntity;
public FTPSDelegate(TARGET target) { public FTPSDelegate(TARGET target) {
mTarget = target; mTarget = target;
mUrlEntity = mTarget.getTaskWrapper().asFtp().getUrlEntity(); mUrlEntity = mTarget.getTaskWrapper().asFtp().getUrlEntity();
} }
/** /**
* 设置协议类型 * 设置协议类型
* *
* @param protocol {@link ProtocolType} * @param protocol {@link ProtocolType}
*/ */
public FTPSDelegate setProtocol(@ProtocolType String protocol) { public FTPSDelegate setProtocol(@ProtocolType String protocol) {
if (TextUtils.isEmpty(protocol)) { if (TextUtils.isEmpty(protocol)) {
throw new NullPointerException("协议为空"); throw new NullPointerException("协议为空");
} }
mUrlEntity.protocol = protocol; mUrlEntity.protocol = protocol;
return this; return this;
} }
/** /**
* 设置证书别名 * 设置证书别名
* *
* @param keyAlias 别名 * @param keyAlias 别名
*/ */
public FTPSDelegate setAlias(String keyAlias) { public FTPSDelegate setAlias(String keyAlias) {
if (TextUtils.isEmpty(keyAlias)) { if (TextUtils.isEmpty(keyAlias)) {
throw new NullPointerException("别名为空"); throw new NullPointerException("别名为空");
} }
mUrlEntity.keyAlias = keyAlias; mUrlEntity.keyAlias = keyAlias;
return this; return this;
} }
/** /**
* 设置证书密码 * 设置证书密码
* *
* @param storePass 私钥密码 * @param storePass 私钥密码
*/ */
public FTPSDelegate setStorePass(String storePass) { public FTPSDelegate setStorePass(String storePass) {
if (TextUtils.isEmpty(storePass)) { if (TextUtils.isEmpty(storePass)) {
throw new NullPointerException("证书密码为空"); throw new NullPointerException("证书密码为空");
} }
mUrlEntity.storePass = storePass; mUrlEntity.storePass = storePass;
return this; return this;
} }
/** /**
* 设置证书路径 * 设置证书路径
* *
* @param storePath 证书路径 * @param storePath 证书路径
*/ */
public FTPSDelegate setStorePath(String storePath) { public FTPSDelegate setStorePath(String storePath) {
if (TextUtils.isEmpty(storePath)) { if (TextUtils.isEmpty(storePath)) {
throw new NullPointerException("证书路径为空"); throw new NullPointerException("证书路径为空");
} }
mUrlEntity.storePath = storePath; mUrlEntity.storePath = storePath;
return this; return this;
} }
@Override public void start() { @Override public void add() {
mTarget.start(); mTarget.add();
} }
@Override public void stop() { @Override public void start() {
mTarget.stop(); mTarget.start();
} }
@Override public void resume() { @Override public void stop() {
mTarget.resume(); mTarget.stop();
} }
@Override public void cancel() { @Override public void resume() {
mTarget.cancel(); mTarget.resume();
} }
@Override public void save() { @Override public void cancel() {
mTarget.save(); mTarget.cancel();
} }
@Override public void cancel(boolean removeFile) { @Override public void save() {
mTarget.cancel(removeFile); mTarget.save();
} }
@Override public void reTry() { @Override public void cancel(boolean removeFile) {
mTarget.reTry(); mTarget.cancel(removeFile);
} }
@Override public void reStart() { @Override public void reTry() {
mTarget.reStart(); mTarget.reTry();
} }
}
@Override public void reStart() {
mTarget.reStart();
}
}

@ -1,62 +1,62 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.common.ftp; package com.arialyy.aria.core.common.ftp;
import com.arialyy.aria.core.FtpUrlEntity; import com.arialyy.aria.core.FtpUrlEntity;
import com.arialyy.aria.core.inf.ITaskDelegate; import com.arialyy.aria.core.inf.ITargetHeadDelegate;
import java.net.Proxy; import java.net.Proxy;
/** /**
* fTP任务设置的信息用户名密码端口等信息 * fTP任务设置的信息用户名密码端口等信息
*/ */
public class FtpTaskDelegate implements ITaskDelegate { public class FtpTaskDelegate implements ITargetHeadDelegate {
/** /**
* 账号和密码 * 账号和密码
*/ */
private FtpUrlEntity urlEntity; private FtpUrlEntity urlEntity;
private Proxy proxy; private Proxy proxy;
/** /**
* 字符编码默认为"utf-8" * 字符编码默认为"utf-8"
*/ */
private String charSet = "utf-8"; private String charSet = "utf-8";
public FtpUrlEntity getUrlEntity() { public FtpUrlEntity getUrlEntity() {
return urlEntity; return urlEntity;
} }
public void setUrlEntity(FtpUrlEntity urlEntity) { public void setUrlEntity(FtpUrlEntity urlEntity) {
this.urlEntity = urlEntity; this.urlEntity = urlEntity;
} }
public void setProxy(Proxy proxy) { public void setProxy(Proxy proxy) {
this.proxy = proxy; this.proxy = proxy;
} }
public Proxy getProxy() { public Proxy getProxy() {
return proxy; return proxy;
} }
public String getCharSet() { public String getCharSet() {
return charSet; return charSet;
} }
public void setCharSet(String charSet) { public void setCharSet(String charSet) {
this.charSet = charSet; this.charSet = charSet;
} }
} }

@ -1,100 +1,104 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.common.http; package com.arialyy.aria.core.common.http;
import android.text.TextUtils; import android.text.TextUtils;
import com.arialyy.aria.core.download.DGTaskWrapper; import com.arialyy.aria.core.download.DGTaskWrapper;
import com.arialyy.aria.core.download.DTaskWrapper; import com.arialyy.aria.core.download.DTaskWrapper;
import com.arialyy.aria.core.download.DownloadGroupTarget; import com.arialyy.aria.core.download.DownloadGroupTarget;
import com.arialyy.aria.core.inf.AbsTarget; import com.arialyy.aria.core.inf.AbsTarget;
import com.arialyy.aria.core.inf.ITarget; import com.arialyy.aria.core.inf.ITargetHandler;
import com.arialyy.aria.util.ALog; import com.arialyy.aria.util.ALog;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
/** /**
* HTTP参数委托 * HTTP参数委托
* @param <TARGET> * @param <TARGET>
*/ */
class HttpDelegate<TARGET extends AbsTarget> implements ITarget { class HttpDelegate<TARGET extends AbsTarget> implements ITargetHandler {
private static final String TAG = "PostDelegate"; private static final String TAG = "PostDelegate";
TARGET mTarget; TARGET mTarget;
HttpDelegate(TARGET target) { HttpDelegate(TARGET target) {
mTarget = target; mTarget = target;
} }
public TARGET setParams(Map<String, String> params) { public TARGET setParams(Map<String, String> params) {
mTarget.getTaskWrapper().asHttp().setParams(params); mTarget.getTaskWrapper().asHttp().setParams(params);
if (mTarget instanceof DownloadGroupTarget) { if (mTarget instanceof DownloadGroupTarget) {
for (DTaskWrapper subTask : ((DGTaskWrapper) mTarget.getTaskWrapper()).getSubTaskWrapper()) { for (DTaskWrapper subTask : ((DGTaskWrapper) mTarget.getTaskWrapper()).getSubTaskWrapper()) {
subTask.asHttp().setParams(params); subTask.asHttp().setParams(params);
} }
} }
return mTarget; return mTarget;
} }
public TARGET setParam(String key, String value) { public TARGET setParam(String key, String value) {
if (TextUtils.isEmpty(key) || TextUtils.isEmpty(value)) { if (TextUtils.isEmpty(key) || TextUtils.isEmpty(value)) {
ALog.d(TAG, "key 或value 为空"); ALog.d(TAG, "key 或value 为空");
return mTarget; return mTarget;
} }
Map<String, String> params = mTarget.getTaskWrapper().asHttp().getParams(); Map<String, String> params = mTarget.getTaskWrapper().asHttp().getParams();
if (params == null) { if (params == null) {
params = new HashMap<>(); params = new HashMap<>();
mTarget.getTaskWrapper().asHttp().setParams(params); mTarget.getTaskWrapper().asHttp().setParams(params);
} }
params.put(key, value); params.put(key, value);
if (mTarget instanceof DownloadGroupTarget) { if (mTarget instanceof DownloadGroupTarget) {
for (DTaskWrapper subTask : ((DGTaskWrapper) mTarget.getTaskWrapper()).getSubTaskWrapper()) { for (DTaskWrapper subTask : ((DGTaskWrapper) mTarget.getTaskWrapper()).getSubTaskWrapper()) {
subTask.asHttp().setParams(params); subTask.asHttp().setParams(params);
} }
} }
return mTarget; return mTarget;
} }
@Override public void start() { @Override public void add() {
mTarget.start(); mTarget.add();
} }
@Override public void stop() { @Override public void start() {
mTarget.stop(); mTarget.start();
} }
@Override public void resume() { @Override public void stop() {
mTarget.resume(); mTarget.stop();
} }
@Override public void cancel() { @Override public void resume() {
mTarget.cancel(); mTarget.resume();
} }
@Override public void save() { @Override public void cancel() {
mTarget.save(); mTarget.cancel();
} }
@Override public void cancel(boolean removeFile) { @Override public void save() {
mTarget.cancel(removeFile); mTarget.save();
} }
@Override public void reTry() { @Override public void cancel(boolean removeFile) {
mTarget.reTry(); mTarget.cancel(removeFile);
} }
@Override public void reStart() { @Override public void reTry() {
mTarget.reStart(); mTarget.reTry();
} }
}
@Override public void reStart() {
mTarget.reStart();
}
}

@ -1,187 +1,187 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.common.http; package com.arialyy.aria.core.common.http;
import com.arialyy.aria.core.common.RequestEnum; import com.arialyy.aria.core.common.RequestEnum;
import com.arialyy.aria.core.inf.ITaskDelegate; import com.arialyy.aria.core.inf.ITargetHeadDelegate;
import java.net.CookieManager; import java.net.CookieManager;
import java.net.Proxy; import java.net.Proxy;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
/** /**
* Http任务设置的信息cookie请求参数 * Http任务设置的信息cookie请求参数
*/ */
public class HttpTaskDelegate implements ITaskDelegate { public class HttpTaskDelegate implements ITargetHeadDelegate {
private CookieManager cookieManager; private CookieManager cookieManager;
/** /**
* 请求参数 * 请求参数
*/ */
private Map<String, String> params; private Map<String, String> params;
/** /**
* http 请求头 * http 请求头
*/ */
private Map<String, String> headers = new HashMap<>(); private Map<String, String> headers = new HashMap<>();
/** /**
* 字符编码默认为"utf-8" * 字符编码默认为"utf-8"
*/ */
private String charSet = "utf-8"; private String charSet = "utf-8";
/** /**
* 网络请求类型 * 网络请求类型
*/ */
private RequestEnum requestEnum = RequestEnum.GET; private RequestEnum requestEnum = RequestEnum.GET;
/** /**
* 是否使用服务器通过content-disposition传递的文件名内容格式{@code attachment; filename="filename.jpg"} {@code true} * 是否使用服务器通过content-disposition传递的文件名内容格式{@code attachment; filename="filename.jpg"} {@code true}
* 使用 * 使用
*/ */
private boolean useServerFileName = false; private boolean useServerFileName = false;
/** /**
* 重定向链接 * 重定向链接
*/ */
private String redirectUrl = ""; private String redirectUrl = "";
/** /**
* 是否是chunk模式 * 是否是chunk模式
*/ */
private boolean isChunked = false; private boolean isChunked = false;
/** /**
* 文件上传需要的key * 文件上传需要的key
*/ */
private String attachment; private String attachment;
/** /**
* 上传的文件类型 * 上传的文件类型
*/ */
private String contentType = "multipart/form-data"; private String contentType = "multipart/form-data";
private String userAgent = "Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.6)"; private String userAgent = "Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.6)";
private Proxy proxy; private Proxy proxy;
/** /**
* 文件上传表单 * 文件上传表单
*/ */
private Map<String, String> formFields = new HashMap<>(); private Map<String, String> formFields = new HashMap<>();
public Map<String, String> getFormFields() { public Map<String, String> getFormFields() {
return formFields; return formFields;
} }
public void setFormFields(Map<String, String> formFields) { public void setFormFields(Map<String, String> formFields) {
this.formFields = formFields; this.formFields = formFields;
} }
public String getAttachment() { public String getAttachment() {
return attachment; return attachment;
} }
public void setAttachment(String attachment) { public void setAttachment(String attachment) {
this.attachment = attachment; this.attachment = attachment;
} }
public String getContentType() { public String getContentType() {
return contentType; return contentType;
} }
public void setContentType(String contentType) { public void setContentType(String contentType) {
this.contentType = contentType; this.contentType = contentType;
} }
public String getUserAgent() { public String getUserAgent() {
return userAgent; return userAgent;
} }
public void setUserAgent(String userAgent) { public void setUserAgent(String userAgent) {
this.userAgent = userAgent; this.userAgent = userAgent;
} }
public boolean isChunked() { public boolean isChunked() {
return isChunked; return isChunked;
} }
public void setChunked(boolean chunked) { public void setChunked(boolean chunked) {
isChunked = chunked; isChunked = chunked;
} }
public CookieManager getCookieManager() { public CookieManager getCookieManager() {
return cookieManager; return cookieManager;
} }
public void setCookieManager(CookieManager cookieManager) { public void setCookieManager(CookieManager cookieManager) {
this.cookieManager = cookieManager; this.cookieManager = cookieManager;
} }
public Proxy getProxy() { public Proxy getProxy() {
return proxy; return proxy;
} }
public void setProxy(Proxy proxy) { public void setProxy(Proxy proxy) {
this.proxy = proxy; this.proxy = proxy;
} }
public Map<String, String> getHeaders() { public Map<String, String> getHeaders() {
return headers; return headers;
} }
public void setHeaders(Map<String, String> headers) { public void setHeaders(Map<String, String> headers) {
this.headers = headers; this.headers = headers;
} }
public String getCharSet() { public String getCharSet() {
return charSet; return charSet;
} }
public void setCharSet(String charSet) { public void setCharSet(String charSet) {
this.charSet = charSet; this.charSet = charSet;
} }
public RequestEnum getRequestEnum() { public RequestEnum getRequestEnum() {
return requestEnum; return requestEnum;
} }
public void setRequestEnum(RequestEnum requestEnum) { public void setRequestEnum(RequestEnum requestEnum) {
this.requestEnum = requestEnum; this.requestEnum = requestEnum;
} }
public boolean isUseServerFileName() { public boolean isUseServerFileName() {
return useServerFileName; return useServerFileName;
} }
public void setUseServerFileName(boolean useServerFileName) { public void setUseServerFileName(boolean useServerFileName) {
this.useServerFileName = useServerFileName; this.useServerFileName = useServerFileName;
} }
public String getRedirectUrl() { public String getRedirectUrl() {
return redirectUrl; return redirectUrl;
} }
public void setRedirectUrl(String redirectUrl) { public void setRedirectUrl(String redirectUrl) {
this.redirectUrl = redirectUrl; this.redirectUrl = redirectUrl;
} }
public Map<String, String> getParams() { public Map<String, String> getParams() {
return params; return params;
} }
public void setParams(Map<String, String> params) { public void setParams(Map<String, String> params) {
this.params = params; this.params = params;
} }
} }

@ -1,102 +1,121 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.download; package com.arialyy.aria.core.download;
import com.arialyy.aria.core.AriaManager; import com.arialyy.aria.core.AriaManager;
import com.arialyy.aria.core.command.normal.NormalCmdFactory; import com.arialyy.aria.core.command.normal.NormalCmdFactory;
import com.arialyy.aria.core.inf.AbsEntity; import com.arialyy.aria.core.inf.AbsTarget;
import com.arialyy.aria.core.inf.AbsTarget; import com.arialyy.aria.util.CommonUtil;
import com.arialyy.aria.core.inf.AbsTaskWrapper;
import com.arialyy.aria.util.CommonUtil; /**
* Created by lyy on 2017/2/28.
/** */
* Created by lyy on 2017/2/28. abstract class AbsDownloadTarget<TARGET extends AbsDownloadTarget>
*/ extends AbsTarget<TARGET, DownloadEntity, DTaskWrapper> {
abstract class AbsDownloadTarget<TARGET extends AbsTarget, ENTITY extends AbsEntity, TASK_ENTITY extends AbsTaskWrapper>
extends AbsTarget<TARGET, ENTITY, TASK_ENTITY> { /**
* 设置的文件保存路径的临时变量
static final int HTTP = 1; */
static final int FTP = 2; private String mTempFilePath;
//HTTP任务组
static final int GROUP_HTTP = 3; /**
//FTP文件夹 * {@code true}强制下载不考虑文件路径是否被占用
static final int GROUP_FTP_DIR = 4; */
private boolean forceDownload = false;
/** /**
* 设置的文件保存路径的临时变量 * 资源地址
*/ */
String mTempFilePath; private String mUrl, mNewUrl;
/** /**
* {@code true}强制下载不考虑文件路径是否被占用 * 更新下载url
*/ *
boolean forceDownload = false; * @param newUrl 新的下载url
*/
/** public abstract TARGET updateUrl(String newUrl);
* 将任务设置为最高优先级任务最高优先级任务有以下特点
* 1在下载队列中有且只有一个最高优先级任务 /**
* 2最高优先级任务会一直存在直到用户手动暂停或任务完成 * 将任务设置为最高优先级任务最高优先级任务有以下特点
* 3任务调度器不会暂停最高优先级任务 * 1在下载队列中有且只有一个最高优先级任务
* 4用户手动暂停或任务完成后第二次重新执行该任务该命令将失效 * 2最高优先级任务会一直存在直到用户手动暂停或任务完成
* 5如果下载队列中已经满了则会停止队尾的任务当高优先级任务完成后该队尾任务将自动执行 * 3任务调度器不会暂停最高优先级任务
* 6把任务设置为最高优先级任务后将自动执行任务不需要重新调用start()启动任务 * 4用户手动暂停或任务完成后第二次重新执行该任务该命令将失效
*/ * 5如果下载队列中已经满了则会停止队尾的任务当高优先级任务完成后该队尾任务将自动执行
protected void setHighestPriority() { * 6把任务设置为最高优先级任务后将自动执行任务不需要重新调用start()启动任务
if (checkEntity()) { */
AriaManager.getInstance(AriaManager.APP) public void setHighestPriority() {
.setCmd(CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_HIGHEST_PRIORITY, if (checkEntity()) {
checkTaskType())) AriaManager.getInstance(AriaManager.APP)
.exe(); .setCmd(
} CommonUtil.createNormalCmd(getTaskWrapper(), NormalCmdFactory.TASK_HIGHEST_PRIORITY,
} checkTaskType()))
.exe();
/** }
* 添加任务 }
*/
public void add() { /**
if (checkEntity()) { * 是否强制下载文件 {@link DownloadTarget#setFilePath(String, boolean)}
AriaManager.getInstance(AriaManager.APP) * {@link FtpDownloadTarget#setFilePath(String, boolean)}
.setCmd(CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_CREATE, *
checkTaskType())) * @return {@code true} 强制下载文件
.exe(); */
} boolean isForceDownload() {
} return forceDownload;
}
/**
* 获取任务文件大小 @Override public void setTaskWrapper(DTaskWrapper taskWrapper) {
* super.setTaskWrapper(taskWrapper);
* @return 文件大小 }
*/
public long getFileSize() { /**
return getSize(); * 文件保存路径的临时变量
} */
String getTempFilePath() {
/** return mTempFilePath;
* 获取单位转换后的文件大小 }
*
* @return 文件大小{@code xxx mb} void setForceDownload(boolean forceDownload) {
*/ this.forceDownload = forceDownload;
public String getConvertFileSize() { }
return getConvertSize();
} public String getUrl() {
return mUrl;
/** }
* 设置target类型
* void setUrl(String url) {
* @return {@link #HTTP}{@link #FTP}{@link #GROUP_HTTP}{@link #GROUP_FTP_DIR} this.mUrl = url;
*/ }
protected abstract int getTargetType();
} String getNewUrl() {
return mNewUrl;
}
void setNewUrl(String newUrl) {
this.mNewUrl = newUrl;
}
void setTempFilePath(String mTempFilePath) {
this.mTempFilePath = mTempFilePath;
}
public void setEntity(DownloadEntity entity) {
mEntity = entity;
}
@Override public DownloadEntity getEntity() {
return super.getEntity();
}
}

@ -18,6 +18,7 @@ package com.arialyy.aria.core.download;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.text.TextUtils; import android.text.TextUtils;
import com.arialyy.aria.core.inf.AbsEntity; import com.arialyy.aria.core.inf.AbsEntity;
import com.arialyy.aria.core.inf.AbsTarget;
import com.arialyy.aria.core.manager.SubTaskManager; import com.arialyy.aria.core.manager.SubTaskManager;
import com.arialyy.aria.core.queue.DownloadGroupTaskQueue; import com.arialyy.aria.core.queue.DownloadGroupTaskQueue;
import com.arialyy.aria.orm.DbEntity; import com.arialyy.aria.orm.DbEntity;
@ -30,7 +31,7 @@ import java.util.List;
* Created by lyy on 2017/7/26. * Created by lyy on 2017/7/26.
*/ */
abstract class BaseGroupTarget<TARGET extends BaseGroupTarget> abstract class BaseGroupTarget<TARGET extends BaseGroupTarget>
extends AbsDownloadTarget<TARGET, DownloadGroupEntity, DGTaskWrapper> { extends AbsTarget<TARGET, DownloadGroupEntity, DGTaskWrapper> {
/** /**
* 组任务名 * 组任务名
@ -55,7 +56,7 @@ abstract class BaseGroupTarget<TARGET extends BaseGroupTarget>
@CheckResult @CheckResult
public SubTaskManager getSubTaskManager() { public SubTaskManager getSubTaskManager() {
if (mSubTaskManager == null) { if (mSubTaskManager == null) {
mSubTaskManager = new SubTaskManager(mTargetName, mTaskWrapper); mSubTaskManager = new SubTaskManager(getTargetName(), getTaskWrapper());
} }
return mSubTaskManager; return mSubTaskManager;
} }
@ -122,7 +123,7 @@ abstract class BaseGroupTarget<TARGET extends BaseGroupTarget>
* @param newDirPath 新的文件夹路径 * @param newDirPath 新的文件夹路径
*/ */
void reChangeDirPath(String newDirPath) { void reChangeDirPath(String newDirPath) {
List<DTaskWrapper> subTasks = mTaskWrapper.getSubTaskWrapper(); List<DTaskWrapper> subTasks = getTaskWrapper().getSubTaskWrapper();
if (subTasks != null && !subTasks.isEmpty()) { if (subTasks != null && !subTasks.isEmpty()) {
List<DbEntity> des = new ArrayList<>(); List<DbEntity> des = new ArrayList<>();
for (DTaskWrapper dte : subTasks) { for (DTaskWrapper dte : subTasks) {

@ -1,207 +1,199 @@
/* ///*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) // * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* // *
* Licensed under the Apache License, Version 2.0 (the "License"); // * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. // * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at // * You may obtain a copy of the License at
* // *
* http://www.apache.org/licenses/LICENSE-2.0 // * http://www.apache.org/licenses/LICENSE-2.0
* // *
* Unless required by applicable law or agreed to in writing, software // * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, // * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and // * See the License for the specific language governing permissions and
* limitations under the License. // * limitations under the License.
*/ // */
package com.arialyy.aria.core.download; //package com.arialyy.aria.core.download;
//
import android.text.TextUtils; //import android.text.TextUtils;
import com.arialyy.aria.core.manager.TaskWrapperManager; //import com.arialyy.aria.core.manager.TaskWrapperManager;
import com.arialyy.aria.core.queue.DownloadTaskQueue; //import com.arialyy.aria.core.queue.DownloadTaskQueue;
import com.arialyy.aria.orm.DbEntity; //import com.arialyy.aria.orm.DbEntity;
import com.arialyy.aria.util.ALog; //import com.arialyy.aria.util.ALog;
import com.arialyy.aria.util.CommonUtil; //import com.arialyy.aria.util.CommonUtil;
import java.io.File; //import java.io.File;
//
/** ///**
* Created by Aria.Lao on 2017/7/26. // * Created by Aria.Lao on 2017/7/26.
*/ // */
abstract class BaseNormalTarget<TARGET extends BaseNormalTarget> //abstract class BaseNormalTarget<TARGET extends BaseNormalTarget>
extends AbsDownloadTarget<TARGET, DownloadEntity, DTaskWrapper> { // extends AbsDownloadTarget<TARGET, DownloadEntity, DTaskWrapper> {
//
/** // /**
* 资源地址 // * 通过地址初始化target
*/ // */
protected String url, newUrl; // void initTarget(String url, String targetName) {
// setUrl(url);
/** // setTargetName(targetName);
* 通过地址初始化target // setTaskWrapper(TaskWrapperManager.getInstance().getHttpTaskWrapper(DTaskWrapper.class, url));
*/ // mEntity = getTaskWrapper().getEntity();
void initTarget(String url, String targetName) { //
this.url = url; // if (mEntity != null) {
mTargetName = targetName; // setTempFilePath(mEntity.getDownloadPath());
mTaskWrapper = TaskWrapperManager.getInstance().getHttpTaskWrapper(DTaskWrapper.class, url); // }
mEntity = mTaskWrapper.getEntity(); // }
//
if (mEntity != null) { // /**
mTempFilePath = mEntity.getDownloadPath(); // * 更新下载url
} // *
} // * @param newUrl 新的下载url
// */
/** // public TARGET updateUrl(String newUrl) {
* 更新下载url // if (TextUtils.isEmpty(newUrl)) {
* // ALog.e(TAG, "下载url更新失败,newUrl为null");
* @param newUrl 新的下载url // return (TARGET) this;
*/ // }
public TARGET updateUrl(String newUrl) { // if (getUrl().equals(newUrl)) {
if (TextUtils.isEmpty(newUrl)) { // ALog.e(TAG, "下载url更新失败,新的下载url和旧的url一致");
ALog.e(TAG, "下载url更新失败,newUrl为null"); // return (TARGET) this;
return (TARGET) this; // }
} // setNewUrl(newUrl);
if (url.equals(newUrl)) { // getTaskWrapper().setRefreshInfo(true);
ALog.e(TAG, "下载url更新失败,新的下载url和旧的url一致"); // return (TARGET) this;
return (TARGET) this; // }
} //
this.newUrl = newUrl; // /**
mTaskWrapper.setRefreshInfo(true); // * 将任务设置为最高优先级任务,最高优先级任务有以下特点:
return (TARGET) this; // * 1、在下载队列中,有且只有一个最高优先级任务
} // * 2、最高优先级任务会一直存在,直到用户手动暂停或任务完成
// * 3、任务调度器不会暂停最高优先级任务
/** // * 4、用户手动暂停或任务完成后,第二次重新执行该任务,该命令将失效
* 将任务设置为最高优先级任务最高优先级任务有以下特点 1在下载队列中有且只有一个最高优先级任务 2最高优先级任务会一直存在直到用户手动暂停或任务完成 // * 5、如果下载队列中已经满了,则会停止队尾的任务,当高优先级任务完成后,该队尾任务将自动执行
* 3任务调度器不会暂停最高优先级任务 4用户手动暂停或任务完成后第二次重新执行该任务该命令将失效 5如果下载队列中已经满了则会停止队尾的任务当高优先级任务完成后该队尾任务将自动执行 // * 6、把任务设置为最高优先级任务后,将自动执行任务,不需要重新调用start()启动任务
* 6把任务设置为最高优先级任务后将自动执行任务不需要重新调用start()启动任务 // */
*/ // @Override public void setHighestPriority() {
@Override public void setHighestPriority() { // super.setHighestPriority();
super.setHighestPriority(); // }
} //
// /**
/** // * 下载任务是否存在
* 下载任务是否存在 // *
* // * @return {@code true}任务存在
* @return {@code true}任务存在 // */
*/ // @Override public boolean taskExists() {
@Override public boolean taskExists() { // return DbEntity.checkDataExist(DownloadEntity.class, "url=?", getUrl());
return DbEntity.checkDataExist(DownloadEntity.class, "url=?", url); // }
} //
// /**
/** // * 获取下载实体
* 获取下载实体 // */
*/ // public DownloadEntity getDownloadEntity() {
public DownloadEntity getDownloadEntity() { // return mEntity;
return mEntity; // }
} //
// /**
/** // * 是否在下载
* 是否在下载该api后续版本会删除 // *
* // * @return {@code true}任务正在下载
* @deprecated {@link #isRunning()} // */
*/ // @Override public boolean isRunning() {
@Deprecated public boolean isDownloading() { // DownloadTask task = DownloadTaskQueue.getInstance().getTask(mEntity.getKey());
return isRunning(); // return task != null && task.isRunning();
} // }
//
/** // /**
* 是否在下载 // * 检查下载实体,判断实体是否合法 合法标准为:
* // * 1、下载路径不为null,并且下载路径是正常的http或ftp路径
* @return {@code true}任务正在下载 // * 2、保存路径不为null,并且保存路径是android文件系统路径
*/ // * 3、保存路径不能重复
@Override public boolean isRunning() { // *
DownloadTask task = DownloadTaskQueue.getInstance().getTask(mEntity.getKey()); // * @return {@code true}合法
return task != null && task.isRunning(); // */
} // @Override protected boolean checkEntity() {
// boolean b = getTargetType() < GROUP_HTTP && checkUrl() && checkFilePath();
/** // if (b) {
* 检查下载实体判断实体是否合法 合法标准为 1下载路径不为null并且下载路径是正常的http或ftp路径 2保存路径不为null并且保存路径是android文件系统路径 // mEntity.save();
* 3保存路径不能重复 // }
* // return b;
* @return {@code true}合法 // }
*/ //
@Override protected boolean checkEntity() { // /**
boolean b = getTargetType() < GROUP_HTTP && checkUrl() && checkFilePath(); // * 检查并设置普通任务的文件保存路径
if (b) { // *
mEntity.save(); // * @return {@code true}保存路径合法
} // */
return b; // private boolean checkFilePath() {
} // String filePath = getTempFilePath();
// if (TextUtils.isEmpty(filePath)) {
/** // ALog.e(TAG, "下载失败,文件保存路径为null");
* 检查并设置普通任务的文件保存路径 // return false;
* // } else if (!filePath.startsWith("/")) {
* @return {@code true}保存路径合法 // ALog.e(TAG, "下载失败,文件保存路径【" + filePath + "】错误");
*/ // return false;
private boolean checkFilePath() { // }
String filePath = mTempFilePath; // File file = new File(filePath);
if (TextUtils.isEmpty(filePath)) { // if (file.isDirectory()) {
ALog.e(TAG, "下载失败,文件保存路径为null"); // if (getTargetType() == HTTP) {
return false; // ALog.e(TAG, "下载失败,保存路径【" + filePath + "】不能为文件夹,路径需要是完整的文件路径,如:/mnt/sdcard/game.zip");
} else if (!filePath.startsWith("/")) { // return false;
ALog.e(TAG, "下载失败,文件保存路径【" + filePath + "】错误"); // } else if (getTargetType() == FTP) {
return false; // filePath += mEntity.getFileName();
} // }
File file = new File(filePath); // } else {
if (file.isDirectory()) { // // http文件名设置
if (getTargetType() == HTTP) { // if (TextUtils.isEmpty(mEntity.getFileName())) {
ALog.e(TAG, "下载失败,保存路径【" + filePath + "】不能为文件夹,路径需要是完整的文件路径,如:/mnt/sdcard/game.zip"); // mEntity.setFileName(file.getName());
return false; // }
} else if (getTargetType() == FTP) { // }
filePath += mEntity.getFileName(); //
} // //设置文件保存路径,如果新文件路径和旧文件路径不同,则修改路径
} else { // if (!filePath.equals(mEntity.getDownloadPath())) {
// http文件名设置 // // 检查路径冲突
if (TextUtils.isEmpty(mEntity.getFileName())) { // if (DbEntity.checkDataExist(DownloadEntity.class, "downloadPath=?", filePath)) {
mEntity.setFileName(file.getName()); // if (!isForceDownload()) {
} // ALog.e(TAG, "下载失败,保存路径【" + filePath + "】已经被其它任务占用,请设置其它保存路径");
} // return false;
// } else {
//设置文件保存路径,如果新文件路径和旧文件路径不同,则修改路径 // ALog.w(TAG, "保存路径【" + filePath + "】已经被其它任务占用,当前任务将覆盖该路径的文件");
if (!filePath.equals(mEntity.getDownloadPath())) { // CommonUtil.delTaskRecord(filePath, 1);
// 检查路径冲突 // setTaskWrapper(
if (DbEntity.checkDataExist(DownloadEntity.class, "downloadPath=?", filePath)) { // TaskWrapperManager.getInstance().getHttpTaskWrapper(DTaskWrapper.class, getUrl()));
if (!forceDownload) { // }
ALog.e(TAG, "下载失败,保存路径【" + filePath + "】已经被其它任务占用,请设置其它保存路径"); // }
return false; // File oldFile = new File(mEntity.getDownloadPath());
} else { // File newFile = new File(filePath);
ALog.w(TAG, "保存路径【" + filePath + "】已经被其它任务占用,当前任务将覆盖该路径的文件"); // mEntity.setDownloadPath(filePath);
CommonUtil.delTaskRecord(filePath, 1); // mEntity.setFileName(newFile.getName());
mTaskWrapper = // if (oldFile.exists()) {
TaskWrapperManager.getInstance().getHttpTaskWrapper(DTaskWrapper.class, url); // oldFile.renameTo(newFile);
} // CommonUtil.modifyTaskRecord(oldFile.getPath(), newFile.getPath());
} // }
File oldFile = new File(mEntity.getDownloadPath()); // }
File newFile = new File(filePath); // return true;
mEntity.setDownloadPath(filePath); // }
mEntity.setFileName(newFile.getName()); //
if (oldFile.exists()) { // /**
oldFile.renameTo(newFile); // * 检查普通任务的下载地址
CommonUtil.modifyTaskRecord(oldFile.getPath(), newFile.getPath()); // *
} // * @return {@code true}地址合法
} // */
return true; // private boolean checkUrl() {
} // final String url = mEntity.getUrl();
// if (TextUtils.isEmpty(url)) {
/** // ALog.e(TAG, "下载失败,url为null");
* 检查普通任务的下载地址 // return false;
* // } else if (!url.startsWith("http") && !url.startsWith("ftp")) {
* @return {@code true}地址合法 // ALog.e(TAG, "下载失败,url【" + url + "】错误");
*/ // return false;
private boolean checkUrl() { // }
final String url = mEntity.getUrl(); // int index = url.indexOf("://");
if (TextUtils.isEmpty(url)) { // if (index == -1) {
ALog.e(TAG, "下载失败,url为null"); // ALog.e(TAG, "下载失败,url【" + url + "】不合法");
return false; // return false;
} else if (!url.startsWith("http") && !url.startsWith("ftp")) { // }
ALog.e(TAG, "下载失败,url【" + url + "】错误"); // if (!TextUtils.isEmpty(getNewUrl())) {
return false; // mEntity.setUrl(getNewUrl());
} // }
int index = url.indexOf("://"); // return true;
if (index == -1) { // }
ALog.e(TAG, "下载失败,url【" + url + "】不合法"); //}
return false;
}
if (!TextUtils.isEmpty(newUrl)) {
mEntity.setUrl(newUrl);
}
return true;
}
}

@ -0,0 +1,161 @@
/*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
*
* 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.arialyy.aria.core.download;
import android.text.TextUtils;
import com.arialyy.aria.core.inf.ITargetHandler;
import com.arialyy.aria.core.inf.ITargetNormal;
import com.arialyy.aria.core.manager.TaskWrapperManager;
import com.arialyy.aria.core.queue.DownloadTaskQueue;
import com.arialyy.aria.orm.DbEntity;
import com.arialyy.aria.util.ALog;
import com.arialyy.aria.util.CommonUtil;
import java.io.File;
/**
* Created by AriaL on 2019/4/5.
* 普通下载任务通用功能处理
*/
class DNormalDelegate<TARGET extends AbsDownloadTarget> implements ITargetNormal<TARGET> {
private final String TAG = "DNormalDelegate";
private DownloadEntity mEntity;
private TARGET target;
DNormalDelegate(TARGET target, String url, String targetName) {
this.target = target;
initTarget(url, targetName);
}
@Override public void initTarget(String url, String targetName) {
DTaskWrapper taskWrapper = TaskWrapperManager.getInstance().getHttpTaskWrapper(DTaskWrapper.class, url);
mEntity = taskWrapper.getEntity();
target.setUrl(url);
target.setTargetName(targetName);
target.setTaskWrapper(taskWrapper);
target.setEntity(mEntity);
if (mEntity != null) {
target.setTempFilePath(mEntity.getDownloadPath());
}
}
@Override public TARGET updateUrl(String newUrl) {
if (TextUtils.isEmpty(newUrl)) {
ALog.e(TAG, "下载url更新失败,newUrl为null");
return target;
}
if (target.getUrl().equals(newUrl)) {
ALog.e(TAG, "下载url更新失败,新的下载url和旧的url一致");
return target;
}
target.setNewUrl(newUrl);
target.getTaskWrapper().setRefreshInfo(true);
return target;
}
@Override public DownloadEntity getEntity() {
return target.getEntity();
}
@Override public boolean taskExists() {
return DbEntity.checkDataExist(DownloadEntity.class, "url=?", target.getUrl());
}
@Override public boolean isRunning() {
DownloadTask task = DownloadTaskQueue.getInstance().getTask(mEntity.getKey());
return task != null && task.isRunning();
}
@Override public boolean checkEntity() {
boolean b = checkUrl() && checkFilePath();
if (b) {
mEntity.save();
}
return b;
}
@Override public boolean checkFilePath() {
String filePath = target.getTempFilePath();
if (TextUtils.isEmpty(filePath)) {
ALog.e(TAG, "下载失败,文件保存路径为null");
return false;
} else if (!filePath.startsWith("/")) {
ALog.e(TAG, "下载失败,文件保存路径【" + filePath + "】错误");
return false;
}
File file = new File(filePath);
if (file.isDirectory()) {
if (target.getTargetType() == ITargetHandler.HTTP) {
ALog.e(TAG, "下载失败,保存路径【" + filePath + "】不能为文件夹,路径需要是完整的文件路径,如:/mnt/sdcard/game.zip");
return false;
} else if (target.getTargetType() == ITargetHandler.FTP) {
filePath += mEntity.getFileName();
}
} else {
// http文件名设置
if (TextUtils.isEmpty(mEntity.getFileName())) {
mEntity.setFileName(file.getName());
}
}
//设置文件保存路径,如果新文件路径和旧文件路径不同,则修改路径
if (!filePath.equals(mEntity.getDownloadPath())) {
// 检查路径冲突
if (DbEntity.checkDataExist(DownloadEntity.class, "downloadPath=?", filePath)) {
if (!target.isForceDownload()) {
ALog.e(TAG, "下载失败,保存路径【" + filePath + "】已经被其它任务占用,请设置其它保存路径");
return false;
} else {
ALog.w(TAG, "保存路径【" + filePath + "】已经被其它任务占用,当前任务将覆盖该路径的文件");
CommonUtil.delTaskRecord(filePath, 1);
target.setTaskWrapper(
TaskWrapperManager.getInstance()
.getHttpTaskWrapper(DTaskWrapper.class, target.getUrl()));
}
}
File oldFile = new File(mEntity.getDownloadPath());
File newFile = new File(filePath);
mEntity.setDownloadPath(filePath);
mEntity.setFileName(newFile.getName());
if (oldFile.exists()) {
oldFile.renameTo(newFile);
CommonUtil.modifyTaskRecord(oldFile.getPath(), newFile.getPath());
}
}
return true;
}
@Override public boolean checkUrl() {
final String url = mEntity.getUrl();
if (TextUtils.isEmpty(url)) {
ALog.e(TAG, "下载失败,url为null");
return false;
} else if (!url.startsWith("http") && !url.startsWith("ftp")) {
ALog.e(TAG, "下载失败,url【" + url + "】错误");
return false;
}
int index = url.indexOf("://");
if (index == -1) {
ALog.e(TAG, "下载失败,url【" + url + "】不合法");
return false;
}
if (!TextUtils.isEmpty(target.getNewUrl())) {
mEntity.setUrl(target.getNewUrl());
}
return true;
}
}

@ -1,337 +1,337 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.download; package com.arialyy.aria.core.download;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.support.annotation.NonNull; import android.support.annotation.NonNull;
import android.text.TextUtils; import android.text.TextUtils;
import com.arialyy.aria.core.common.RequestEnum; import com.arialyy.aria.core.common.RequestEnum;
import com.arialyy.aria.core.common.http.HttpHeaderDelegate; import com.arialyy.aria.core.common.http.HttpHeaderDelegate;
import com.arialyy.aria.core.common.http.PostDelegate; import com.arialyy.aria.core.common.http.PostDelegate;
import com.arialyy.aria.core.inf.IHttpHeaderDelegate; import com.arialyy.aria.core.inf.IHttpHeaderDelegate;
import com.arialyy.aria.core.manager.TaskWrapperManager; import com.arialyy.aria.core.manager.TaskWrapperManager;
import com.arialyy.aria.orm.DbEntity; import com.arialyy.aria.orm.DbEntity;
import com.arialyy.aria.util.ALog; import com.arialyy.aria.util.ALog;
import com.arialyy.aria.util.CommonUtil; import com.arialyy.aria.util.CommonUtil;
import java.io.File; import java.io.File;
import java.net.Proxy; import java.net.Proxy;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
/** /**
* Created by AriaL on 2017/6/29. * Created by AriaL on 2017/6/29.
* 下载任务组 * 下载任务组
*/ */
public class DownloadGroupTarget extends BaseGroupTarget<DownloadGroupTarget> implements public class DownloadGroupTarget extends BaseGroupTarget<DownloadGroupTarget> implements
IHttpHeaderDelegate<DownloadGroupTarget> { IHttpHeaderDelegate<DownloadGroupTarget> {
private HttpHeaderDelegate<DownloadGroupTarget> mDelegate; private HttpHeaderDelegate<DownloadGroupTarget> mDelegate;
/** /**
* 子任务下载地址 * 子任务下载地址
*/ */
private List<String> mUrls = new ArrayList<>(); private List<String> mUrls = new ArrayList<>();
/** /**
* 子任务文件名 * 子任务文件名
*/ */
private List<String> mSubNameTemp = new ArrayList<>(); private List<String> mSubNameTemp = new ArrayList<>();
public DownloadGroupTarget(DownloadGroupEntity groupEntity, String targetName) { public DownloadGroupTarget(DownloadGroupEntity groupEntity, String targetName) {
this.mTargetName = targetName; setTargetName(targetName);
if (groupEntity.getUrls() != null && !groupEntity.getUrls().isEmpty()) { if (groupEntity.getUrls() != null && !groupEntity.getUrls().isEmpty()) {
this.mUrls.addAll(groupEntity.getUrls()); this.mUrls.addAll(groupEntity.getUrls());
} }
init(); init();
} }
DownloadGroupTarget(List<String> urls, String targetName) { DownloadGroupTarget(List<String> urls, String targetName) {
this.mTargetName = targetName; setTargetName(targetName);
this.mUrls = urls; this.mUrls = urls;
init(); init();
} }
private void init() { private void init() {
mGroupHash = CommonUtil.getMd5Code(mUrls); mGroupHash = CommonUtil.getMd5Code(mUrls);
mTaskWrapper = TaskWrapperManager.getInstance().getDGTaskWrapper(DGTaskWrapper.class, mUrls); setTaskWrapper(TaskWrapperManager.getInstance().getDGTaskWrapper(DGTaskWrapper.class, mUrls));
mEntity = mTaskWrapper.getEntity(); mEntity = getEntity();
if (mEntity != null) { if (mEntity != null) {
mDirPathTemp = mEntity.getDirPath(); mDirPathTemp = mEntity.getDirPath();
} }
mDelegate = new HttpHeaderDelegate<>(this); mDelegate = new HttpHeaderDelegate<>(this);
} }
/** /**
* Post处理 * Post处理
*/ */
public PostDelegate asPost() { public PostDelegate asPost() {
return new PostDelegate<>(this); return new PostDelegate<>(this);
} }
/** /**
* 更新组合任务下载地址 * 更新组合任务下载地址
* *
* @param urls 新的组合任务下载地址列表 * @param urls 新的组合任务下载地址列表
*/ */
@CheckResult @CheckResult
public DownloadGroupTarget updateUrls(List<String> urls) { public DownloadGroupTarget updateUrls(List<String> urls) {
if (urls == null || urls.isEmpty()) { if (urls == null || urls.isEmpty()) {
throw new NullPointerException("下载地址列表为空"); throw new NullPointerException("下载地址列表为空");
} }
if (urls.size() != mUrls.size()) { if (urls.size() != mUrls.size()) {
throw new IllegalArgumentException("新下载地址数量和旧下载地址数量不一致"); throw new IllegalArgumentException("新下载地址数量和旧下载地址数量不一致");
} }
mUrls.clear(); mUrls.clear();
mUrls.addAll(urls); mUrls.addAll(urls);
mGroupHash = CommonUtil.getMd5Code(urls); mGroupHash = CommonUtil.getMd5Code(urls);
mEntity.setGroupHash(mGroupHash); mEntity.setGroupHash(mGroupHash);
mEntity.update(); mEntity.update();
if (mEntity.getSubEntities() != null && !mEntity.getSubEntities().isEmpty()) { if (mEntity.getSubEntities() != null && !mEntity.getSubEntities().isEmpty()) {
for (DownloadEntity de : mEntity.getSubEntities()) { for (DownloadEntity de : mEntity.getSubEntities()) {
de.setGroupHash(mGroupHash); de.setGroupHash(mGroupHash);
de.update(); de.update();
} }
} }
return this; return this;
} }
/** /**
* 任务组总任务大小任务组是一个抽象的概念没有真实的数据实体任务组的大小是Aria动态获取子任务大小相加而得到的 * 任务组总任务大小任务组是一个抽象的概念没有真实的数据实体任务组的大小是Aria动态获取子任务大小相加而得到的
* 如果你知道当前任务组总大小你也可以调用该方法给任务组设置大小 * 如果你知道当前任务组总大小你也可以调用该方法给任务组设置大小
* *
* 为了更好的用户体验组合任务必须设置文件大小 * 为了更好的用户体验组合任务必须设置文件大小
* *
* @param fileSize 任务组总大小 * @param fileSize 任务组总大小
*/ */
@CheckResult @CheckResult
public DownloadGroupTarget setFileSize(long fileSize) { public DownloadGroupTarget setFileSize(long fileSize) {
if (fileSize <= 0) { if (fileSize <= 0) {
ALog.e(TAG, "文件大小不能小于 0"); ALog.e(TAG, "文件大小不能小于 0");
return this; return this;
} }
if (mEntity.getFileSize() <= 1 || mEntity.getFileSize() != fileSize) { if (mEntity.getFileSize() <= 1 || mEntity.getFileSize() != fileSize) {
mEntity.setFileSize(fileSize); mEntity.setFileSize(fileSize);
} }
return this; return this;
} }
/** /**
* 如果你是使用{@link DownloadReceiver#load(DownloadGroupEntity)}进行下载操作那么你需要设置任务组的下载地址 * 如果你是使用{@link DownloadReceiver#load(DownloadGroupEntity)}进行下载操作那么你需要设置任务组的下载地址
*/ */
@CheckResult @CheckResult
public DownloadGroupTarget setGroupUrl(List<String> urls) { public DownloadGroupTarget setGroupUrl(List<String> urls) {
mUrls.clear(); mUrls.clear();
mUrls.addAll(urls); mUrls.addAll(urls);
return this; return this;
} }
/** /**
* 设置子任务文件名该方法必须在{@link #setDirPath(String)}之后调用否则不生效 * 设置子任务文件名该方法必须在{@link #setDirPath(String)}之后调用否则不生效
* *
* @deprecated {@link #setSubFileName(List)} 请使用该api * @deprecated {@link #setSubFileName(List)} 请使用该api
*/ */
@CheckResult @CheckResult
@Deprecated public DownloadGroupTarget setSubTaskFileName(List<String> subTaskFileName) { @Deprecated public DownloadGroupTarget setSubTaskFileName(List<String> subTaskFileName) {
return setSubFileName(subTaskFileName); return setSubFileName(subTaskFileName);
} }
/** /**
* 设置子任务文件名该方法必须在{@link #setDirPath(String)}之后调用否则不生效 * 设置子任务文件名该方法必须在{@link #setDirPath(String)}之后调用否则不生效
*/ */
@CheckResult @CheckResult
public DownloadGroupTarget setSubFileName(List<String> subTaskFileName) { public DownloadGroupTarget setSubFileName(List<String> subTaskFileName) {
if (subTaskFileName == null || subTaskFileName.isEmpty()) { if (subTaskFileName == null || subTaskFileName.isEmpty()) {
ALog.e(TAG, "修改子任务的文件名失败:列表为null"); ALog.e(TAG, "修改子任务的文件名失败:列表为null");
return this; return this;
} }
if (subTaskFileName.size() != mTaskWrapper.getSubTaskWrapper().size()) { if (subTaskFileName.size() != getTaskWrapper().getSubTaskWrapper().size()) {
ALog.e(TAG, "修改子任务的文件名失败:子任务文件名列表数量和子任务的数量不匹配"); ALog.e(TAG, "修改子任务的文件名失败:子任务文件名列表数量和子任务的数量不匹配");
return this; return this;
} }
mSubNameTemp.clear(); mSubNameTemp.clear();
mSubNameTemp.addAll(subTaskFileName); mSubNameTemp.addAll(subTaskFileName);
return this; return this;
} }
@Override protected int getTargetType() { @Override public int getTargetType() {
return GROUP_HTTP; return GROUP_HTTP;
} }
@Override protected boolean checkEntity() { @Override protected boolean checkEntity() {
if (getTargetType() == GROUP_HTTP) { if (getTargetType() == GROUP_HTTP) {
if (!checkDirPath()) { if (!checkDirPath()) {
return false; return false;
} }
if (!checkSubName()) { if (!checkSubName()) {
return false; return false;
} }
if (!checkUrls()) { if (!checkUrls()) {
return false; return false;
} }
if (mTaskWrapper.getEntity().getFileSize() == 0) { if (getTaskWrapper().getEntity().getFileSize() == 0) {
ALog.e(TAG, "组合任务必须设置文件文件大小"); ALog.e(TAG, "组合任务必须设置文件文件大小");
return false; return false;
} }
if (mTaskWrapper.asHttp().getRequestEnum() == RequestEnum.POST) { if (getTaskWrapper().asHttp().getRequestEnum() == RequestEnum.POST) {
for (DTaskWrapper subTask : mTaskWrapper.getSubTaskWrapper()) { for (DTaskWrapper subTask : getTaskWrapper().getSubTaskWrapper()) {
subTask.asHttp().setRequestEnum(RequestEnum.POST); subTask.asHttp().setRequestEnum(RequestEnum.POST);
} }
} }
mEntity.save(); mEntity.save();
if (needModifyPath) { if (needModifyPath) {
reChangeDirPath(mDirPathTemp); reChangeDirPath(mDirPathTemp);
} }
if (!mSubNameTemp.isEmpty()) { if (!mSubNameTemp.isEmpty()) {
updateSingleSubFileName(); updateSingleSubFileName();
} }
return true; return true;
} }
return false; return false;
} }
/** /**
* 更新所有改动的子任务文件名 * 更新所有改动的子任务文件名
*/ */
private void updateSingleSubFileName() { private void updateSingleSubFileName() {
List<DTaskWrapper> entities = mTaskWrapper.getSubTaskWrapper(); List<DTaskWrapper> entities = getTaskWrapper().getSubTaskWrapper();
int i = 0; int i = 0;
for (DTaskWrapper entity : entities) { for (DTaskWrapper entity : entities) {
if (i < mSubNameTemp.size()) { if (i < mSubNameTemp.size()) {
String newName = mSubNameTemp.get(i); String newName = mSubNameTemp.get(i);
updateSingleSubFileName(entity, newName); updateSingleSubFileName(entity, newName);
} }
i++; i++;
} }
} }
/** /**
* 检查urls是否合法并删除不合法的子任务 * 检查urls是否合法并删除不合法的子任务
* *
* @return {@code true} 合法 * @return {@code true} 合法
*/ */
private boolean checkUrls() { private boolean checkUrls() {
if (mUrls.isEmpty()) { if (mUrls.isEmpty()) {
ALog.e(TAG, "下载失败,子任务下载列表为null"); ALog.e(TAG, "下载失败,子任务下载列表为null");
return false; return false;
} }
Set<Integer> delItem = new HashSet<>(); Set<Integer> delItem = new HashSet<>();
int i = 0; int i = 0;
for (String url : mUrls) { for (String url : mUrls) {
if (TextUtils.isEmpty(url)) { if (TextUtils.isEmpty(url)) {
ALog.e(TAG, "子任务url为null,即将删除该子任务。"); ALog.e(TAG, "子任务url为null,即将删除该子任务。");
delItem.add(i); delItem.add(i);
continue; continue;
} else if (!url.startsWith("http")) { } else if (!url.startsWith("http")) {
//} else if (!url.startsWith("http") && !url.startsWith("ftp")) { //} else if (!url.startsWith("http") && !url.startsWith("ftp")) {
ALog.e(TAG, "子任务url【" + url + "】错误,即将删除该子任务。"); ALog.e(TAG, "子任务url【" + url + "】错误,即将删除该子任务。");
delItem.add(i); delItem.add(i);
continue; continue;
} }
int index = url.indexOf("://"); int index = url.indexOf("://");
if (index == -1) { if (index == -1) {
ALog.e(TAG, "子任务url【" + url + "】不合法,即将删除该子任务。"); ALog.e(TAG, "子任务url【" + url + "】不合法,即将删除该子任务。");
delItem.add(i); delItem.add(i);
continue; continue;
} }
i++; i++;
} }
for (int index : delItem) { for (int index : delItem) {
mUrls.remove(index); mUrls.remove(index);
if (mSubNameTemp != null && !mSubNameTemp.isEmpty()) { if (mSubNameTemp != null && !mSubNameTemp.isEmpty()) {
mSubNameTemp.remove(index); mSubNameTemp.remove(index);
} }
} }
mEntity.setGroupHash(CommonUtil.getMd5Code(mUrls)); mEntity.setGroupHash(CommonUtil.getMd5Code(mUrls));
return true; return true;
} }
/** /**
* 更新单个子任务文件名 * 更新单个子任务文件名
*/ */
private void updateSingleSubFileName(DTaskWrapper taskEntity, String newName) { private void updateSingleSubFileName(DTaskWrapper taskEntity, String newName) {
DownloadEntity entity = taskEntity.getEntity(); DownloadEntity entity = taskEntity.getEntity();
if (!newName.equals(entity.getFileName())) { if (!newName.equals(entity.getFileName())) {
String oldPath = mEntity.getDirPath() + "/" + entity.getFileName(); String oldPath = mEntity.getDirPath() + "/" + entity.getFileName();
String newPath = mEntity.getDirPath() + "/" + newName; String newPath = mEntity.getDirPath() + "/" + newName;
if (DbEntity.checkDataExist(DownloadEntity.class, "downloadPath=? or isComplete='true'", if (DbEntity.checkDataExist(DownloadEntity.class, "downloadPath=? or isComplete='true'",
newPath)) { newPath)) {
ALog.w(TAG, String.format("更新文件名失败,路径【%s】已存在或文件已下载", newPath)); ALog.w(TAG, String.format("更新文件名失败,路径【%s】已存在或文件已下载", newPath));
return; return;
} }
File oldFile = new File(oldPath); File oldFile = new File(oldPath);
if (oldFile.exists()) { if (oldFile.exists()) {
oldFile.renameTo(new File(newPath)); oldFile.renameTo(new File(newPath));
} }
CommonUtil.modifyTaskRecord(oldFile.getPath(), newPath); CommonUtil.modifyTaskRecord(oldFile.getPath(), newPath);
entity.setDownloadPath(newPath); entity.setDownloadPath(newPath);
entity.setFileName(newName); entity.setFileName(newName);
entity.update(); entity.update();
} }
} }
/** /**
* 如果用户设置了子任务文件名检查子任务文件名 * 如果用户设置了子任务文件名检查子任务文件名
* *
* @return {@code true} 合法 * @return {@code true} 合法
*/ */
private boolean checkSubName() { private boolean checkSubName() {
if (mSubNameTemp == null || mSubNameTemp.isEmpty()) { if (mSubNameTemp == null || mSubNameTemp.isEmpty()) {
return true; return true;
} }
if (mUrls.size() != mSubNameTemp.size()) { if (mUrls.size() != mSubNameTemp.size()) {
ALog.e(TAG, "子任务文件名必须和子任务数量一致"); ALog.e(TAG, "子任务文件名必须和子任务数量一致");
return false; return false;
} }
return true; return true;
} }
@CheckResult @CheckResult
@Override public DownloadGroupTarget addHeader(@NonNull String key, @NonNull String value) { @Override public DownloadGroupTarget addHeader(@NonNull String key, @NonNull String value) {
for (DTaskWrapper subTask : mTaskWrapper.getSubTaskWrapper()) { for (DTaskWrapper subTask : getTaskWrapper().getSubTaskWrapper()) {
mDelegate.addHeader(subTask, key, value); mDelegate.addHeader(subTask, key, value);
} }
return mDelegate.addHeader(key, value); return mDelegate.addHeader(key, value);
} }
@CheckResult @CheckResult
@Override public DownloadGroupTarget addHeaders(Map<String, String> headers) { @Override public DownloadGroupTarget addHeaders(Map<String, String> headers) {
for (DTaskWrapper subTask : mTaskWrapper.getSubTaskWrapper()) { for (DTaskWrapper subTask : getTaskWrapper().getSubTaskWrapper()) {
mDelegate.addHeaders(subTask, headers); mDelegate.addHeaders(subTask, headers);
} }
return mDelegate.addHeaders(headers); return mDelegate.addHeaders(headers);
} }
@CheckResult @CheckResult
@Override public DownloadGroupTarget setUrlProxy(Proxy proxy) { @Override public DownloadGroupTarget setUrlProxy(Proxy proxy) {
return mDelegate.setUrlProxy(proxy); return mDelegate.setUrlProxy(proxy);
} }
} }

@ -1,143 +1,159 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.download; package com.arialyy.aria.core.download;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.support.annotation.NonNull; import android.support.annotation.NonNull;
import com.arialyy.aria.core.common.http.GetDelegate; import com.arialyy.aria.core.common.http.GetDelegate;
import com.arialyy.aria.core.common.http.HttpHeaderDelegate; import com.arialyy.aria.core.common.http.HttpHeaderDelegate;
import com.arialyy.aria.core.common.http.PostDelegate; import com.arialyy.aria.core.common.http.PostDelegate;
import com.arialyy.aria.core.inf.IHttpHeaderDelegate; import com.arialyy.aria.core.inf.IHttpHeaderDelegate;
import java.net.Proxy; import java.net.Proxy;
import java.util.Map; import java.util.Map;
/** /**
* Created by lyy on 2016/12/5. * Created by lyy on 2016/12/5.
* https://github.com/AriaLyy/Aria * https://github.com/AriaLyy/Aria
*/ */
public class DownloadTarget extends BaseNormalTarget<DownloadTarget> public class DownloadTarget extends AbsDownloadTarget<DownloadTarget>
implements IHttpHeaderDelegate<DownloadTarget> { implements IHttpHeaderDelegate<DownloadTarget> {
private HttpHeaderDelegate<DownloadTarget> mHeaderDelegate; private HttpHeaderDelegate<DownloadTarget> mHeaderDelegate;
private DNormalDelegate<DownloadTarget> mNormalDelegate;
DownloadTarget(DownloadEntity entity, String targetName) {
this(entity.getUrl(), targetName); DownloadTarget(DownloadEntity entity, String targetName) {
} this(entity.getUrl(), targetName);
}
DownloadTarget(String url, String targetName) {
initTarget(url, targetName); DownloadTarget(String url, String targetName) {
mHeaderDelegate = new HttpHeaderDelegate<>(this); mNormalDelegate = new DNormalDelegate<>(this, url, targetName);
} mHeaderDelegate = new HttpHeaderDelegate<>(this);
}
/**
* Post处理 /**
*/ * Post处理
@CheckResult */
public PostDelegate asPost() { @CheckResult
return new PostDelegate<>(this); public PostDelegate asPost() {
} return new PostDelegate<>(this);
}
/**
* get参数传递 /**
*/ * get参数传递
@CheckResult */
public GetDelegate asGet(){ @CheckResult
return new GetDelegate<>(this); public GetDelegate asGet() {
} return new GetDelegate<>(this);
}
/**
* 是否使用服务器通过content-disposition传递的文件名内容格式{@code attachment;filename=***} /**
* 如果获取不到服务器文件名则使用用户设置的文件名 * 是否使用服务器通过content-disposition传递的文件名内容格式{@code attachment;filename=***}
* * 如果获取不到服务器文件名则使用用户设置的文件名
* @param use {@code true} 使用 *
*/ * @param use {@code true} 使用
@CheckResult */
public DownloadTarget useServerFileName(boolean use) { @CheckResult
mTaskWrapper.asHttp().setUseServerFileName(use); public DownloadTarget useServerFileName(boolean use) {
return this; getTaskWrapper().asHttp().setUseServerFileName(use);
} return this;
}
/**
* 设置文件存储路径 /**
* 该api后续版本会删除 * 设置文件存储路径
* * 该api后续版本会删除
* @param downloadPath 文件保存路径 *
* @deprecated {@link #setFilePath(String)} 请使用这个api * @param downloadPath 文件保存路径
*/ * @deprecated {@link #setFilePath(String)} 请使用这个api
@CheckResult */
@Deprecated public DownloadTarget setDownloadPath(@NonNull String downloadPath) { @CheckResult
return setFilePath(downloadPath); @Deprecated public DownloadTarget setDownloadPath(@NonNull String downloadPath) {
} return setFilePath(downloadPath);
}
/**
* 设置文件存储路径如果需要修改新的文件名修改路径便可 /**
* 原文件路径 /mnt/sdcard/test.zip * 设置文件存储路径如果需要修改新的文件名修改路径便可
* 如果需要将test.zip改为game.zip只需要重新设置文件路径为/mnt/sdcard/game.zip * 原文件路径 /mnt/sdcard/test.zip
* * 如果需要将test.zip改为game.zip只需要重新设置文件路径为/mnt/sdcard/game.zip
* @param filePath 路径必须为文件路径不能为文件夹路径 *
*/ * @param filePath 路径必须为文件路径不能为文件夹路径
@CheckResult */
public DownloadTarget setFilePath(@NonNull String filePath) { @CheckResult
mTempFilePath = filePath; public DownloadTarget setFilePath(@NonNull String filePath) {
return this; setTempFilePath(filePath);
} return this;
}
/**
* 设置文件存储路径如果需要修改新的文件名修改路径便可 /**
* 原文件路径 /mnt/sdcard/test.zip * 设置文件存储路径如果需要修改新的文件名修改路径便可
* 如果需要将test.zip改为game.zip只需要重新设置文件路径为/mnt/sdcard/game.zip * 原文件路径 /mnt/sdcard/test.zip
* * 如果需要将test.zip改为game.zip只需要重新设置文件路径为/mnt/sdcard/game.zip
* @param filePath 路径必须为文件路径不能为文件夹路径 *
* @param forceDownload {@code true}强制下载不考虑未见路径是否被占用 * @param filePath 路径必须为文件路径不能为文件夹路径
*/ * @param forceDownload {@code true}强制下载不考虑文件路径是否被占用
@CheckResult */
public DownloadTarget setFilePath(@NonNull String filePath, boolean forceDownload) { @CheckResult
mTempFilePath = filePath; public DownloadTarget setFilePath(@NonNull String filePath, boolean forceDownload) {
this.forceDownload = forceDownload; setTempFilePath(filePath);
return this; setForceDownload(forceDownload);
} return this;
}
/**
* 从header中获取文件描述信息 /**
*/ * 从header中获取文件描述信息
public String getContentDisposition() { */
return mEntity.getDisposition(); public String getContentDisposition() {
} return mEntity.getDisposition();
}
@Override protected int getTargetType() {
return HTTP; @Override public DownloadTarget updateUrl(String newUrl) {
} return mNormalDelegate.updateUrl(newUrl);
}
/**
* 设置URL的代理 @Override public int getTargetType() {
* return HTTP;
* @param proxy {@link Proxy} }
*/
@CheckResult /**
@Override public DownloadTarget setUrlProxy(Proxy proxy) { * 设置URL的代理
return mHeaderDelegate.setUrlProxy(proxy); *
} * @param proxy {@link Proxy}
*/
@CheckResult @CheckResult
@Override public DownloadTarget addHeader(@NonNull String key, @NonNull String value) { @Override public DownloadTarget setUrlProxy(Proxy proxy) {
return mHeaderDelegate.addHeader(key, value); return mHeaderDelegate.setUrlProxy(proxy);
} }
@CheckResult @CheckResult
@Override public DownloadTarget addHeaders(Map<String, String> headers) { @Override public DownloadTarget addHeader(@NonNull String key, @NonNull String value) {
return mHeaderDelegate.addHeaders(headers); return mHeaderDelegate.addHeader(key, value);
} }
} @CheckResult
@Override public DownloadTarget addHeaders(Map<String, String> headers) {
return mHeaderDelegate.addHeaders(headers);
}
@Override protected boolean checkEntity() {
return mNormalDelegate.checkEntity();
}
@Override public boolean isRunning() {
return mNormalDelegate.isRunning();
}
@Override public boolean taskExists() {
return mNormalDelegate.taskExists();
}
}

@ -1,145 +1,145 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.download; package com.arialyy.aria.core.download;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.text.TextUtils; import android.text.TextUtils;
import com.arialyy.aria.core.FtpUrlEntity; import com.arialyy.aria.core.FtpUrlEntity;
import com.arialyy.aria.core.common.ftp.FTPSDelegate; import com.arialyy.aria.core.common.ftp.FTPSDelegate;
import com.arialyy.aria.core.common.ftp.FtpDelegate; import com.arialyy.aria.core.common.ftp.FtpDelegate;
import com.arialyy.aria.core.inf.AbsTaskWrapper; import com.arialyy.aria.core.inf.AbsTaskWrapper;
import com.arialyy.aria.core.inf.IFtpTarget; import com.arialyy.aria.core.inf.IFtpTarget;
import com.arialyy.aria.core.manager.TaskWrapperManager; import com.arialyy.aria.core.manager.TaskWrapperManager;
import com.arialyy.aria.util.ALog; import com.arialyy.aria.util.ALog;
import java.net.Proxy; import java.net.Proxy;
/** /**
* Created by Aria.Lao on 2017/7/26. * Created by Aria.Lao on 2017/7/26.
* ftp文件夹下载 * ftp文件夹下载
*/ */
public class FtpDirDownloadTarget extends BaseGroupTarget<FtpDirDownloadTarget> public class FtpDirDownloadTarget extends BaseGroupTarget<FtpDirDownloadTarget>
implements IFtpTarget<FtpDirDownloadTarget> { implements IFtpTarget<FtpDirDownloadTarget> {
private FtpDelegate<FtpDirDownloadTarget> mDelegate; private FtpDelegate<FtpDirDownloadTarget> mDelegate;
FtpDirDownloadTarget(String url, String targetName) { FtpDirDownloadTarget(String url, String targetName) {
mTargetName = targetName; setTargetName(targetName);
init(url); init(url);
} }
private void init(String key) { private void init(String key) {
mGroupHash = key; mGroupHash = key;
mTaskWrapper = TaskWrapperManager.getInstance().getFtpTaskWrapper(DGTaskWrapper.class, key); setTaskWrapper(TaskWrapperManager.getInstance().getFtpTaskWrapper(DGTaskWrapper.class, key));
mTaskWrapper.setRequestType(AbsTaskWrapper.D_FTP_DIR); getTaskWrapper().setRequestType(AbsTaskWrapper.D_FTP_DIR);
mEntity = mTaskWrapper.getEntity(); mEntity = getEntity();
if (mEntity != null) { if (mEntity != null) {
mDirPathTemp = mEntity.getDirPath(); mDirPathTemp = mEntity.getDirPath();
} }
mDelegate = new FtpDelegate<>(this); mDelegate = new FtpDelegate<>(this);
} }
@Override protected int getTargetType() { @Override public int getTargetType() {
return GROUP_FTP_DIR; return GROUP_FTP_DIR;
} }
@Override protected boolean checkEntity() { @Override protected boolean checkEntity() {
boolean b = getTargetType() == GROUP_FTP_DIR && checkDirPath() && checkUrl(); boolean b = getTargetType() == GROUP_FTP_DIR && checkDirPath() && checkUrl();
if (b) { if (b) {
mEntity.save(); mEntity.save();
if (mTaskWrapper.getSubTaskWrapper() != null) { if (getTaskWrapper().getSubTaskWrapper() != null) {
//初始化子项的登录信息 //初始化子项的登录信息
FtpUrlEntity tUrlEntity = mTaskWrapper.asFtp().getUrlEntity(); FtpUrlEntity tUrlEntity = getTaskWrapper().asFtp().getUrlEntity();
for (DTaskWrapper wrapper : mTaskWrapper.getSubTaskWrapper()) { for (DTaskWrapper wrapper : getTaskWrapper().getSubTaskWrapper()) {
FtpUrlEntity urlEntity = wrapper.asFtp().getUrlEntity(); FtpUrlEntity urlEntity = wrapper.asFtp().getUrlEntity();
urlEntity.needLogin = tUrlEntity.needLogin; urlEntity.needLogin = tUrlEntity.needLogin;
urlEntity.account = tUrlEntity.account; urlEntity.account = tUrlEntity.account;
urlEntity.user = tUrlEntity.user; urlEntity.user = tUrlEntity.user;
urlEntity.password = tUrlEntity.password; urlEntity.password = tUrlEntity.password;
// 处理ftps详细 // 处理ftps详细
if (tUrlEntity.isFtps) { if (tUrlEntity.isFtps) {
urlEntity.isFtps = true; urlEntity.isFtps = true;
urlEntity.protocol = tUrlEntity.protocol; urlEntity.protocol = tUrlEntity.protocol;
urlEntity.storePath = tUrlEntity.storePath; urlEntity.storePath = tUrlEntity.storePath;
urlEntity.storePass = tUrlEntity.storePass; urlEntity.storePass = tUrlEntity.storePass;
urlEntity.keyAlias = tUrlEntity.keyAlias; urlEntity.keyAlias = tUrlEntity.keyAlias;
} }
} }
} }
} }
if (mTaskWrapper.asFtp().getUrlEntity().isFtps) { if (getTaskWrapper().asFtp().getUrlEntity().isFtps) {
if (TextUtils.isEmpty(mTaskWrapper.asFtp().getUrlEntity().storePath)) { if (TextUtils.isEmpty(getTaskWrapper().asFtp().getUrlEntity().storePath)) {
ALog.e(TAG, "证书路径为空"); ALog.e(TAG, "证书路径为空");
return false; return false;
} }
if (TextUtils.isEmpty(mTaskWrapper.asFtp().getUrlEntity().keyAlias)) { if (TextUtils.isEmpty(getTaskWrapper().asFtp().getUrlEntity().keyAlias)) {
ALog.e(TAG, "证书别名为空"); ALog.e(TAG, "证书别名为空");
return false; return false;
} }
} }
return b; return b;
} }
/** /**
* 检查普通任务的下载地址 * 检查普通任务的下载地址
* *
* @return {@code true}地址合法 * @return {@code true}地址合法
*/ */
private boolean checkUrl() { private boolean checkUrl() {
final String url = mGroupHash; final String url = mGroupHash;
if (TextUtils.isEmpty(url)) { if (TextUtils.isEmpty(url)) {
ALog.e(TAG, "下载失败,url为null"); ALog.e(TAG, "下载失败,url为null");
return false; return false;
} else if (!url.startsWith("ftp")) { } else if (!url.startsWith("ftp")) {
ALog.e(TAG, "下载失败,url【" + url + "】错误"); ALog.e(TAG, "下载失败,url【" + url + "】错误");
return false; return false;
} }
int index = url.indexOf("://"); int index = url.indexOf("://");
if (index == -1) { if (index == -1) {
ALog.e(TAG, "下载失败,url【" + url + "】不合法"); ALog.e(TAG, "下载失败,url【" + url + "】不合法");
return false; return false;
} }
return true; return true;
} }
/** /**
* 是否是FTPS协议 * 是否是FTPS协议
* 如果是FTPS协议需要使用{@link FTPSDelegate#setStorePath(String)} {@link FTPSDelegate#setAlias(String)} * 如果是FTPS协议需要使用{@link FTPSDelegate#setStorePath(String)} {@link FTPSDelegate#setAlias(String)}
* 设置证书信息 * 设置证书信息
*/ */
@CheckResult @CheckResult
public FTPSDelegate<FtpDirDownloadTarget> asFtps() { public FTPSDelegate<FtpDirDownloadTarget> asFtps() {
mTaskWrapper.asFtp().getUrlEntity().isFtps = true; getTaskWrapper().asFtp().getUrlEntity().isFtps = true;
return new FTPSDelegate<>(this); return new FTPSDelegate<>(this);
} }
@CheckResult @CheckResult
@Override public FtpDirDownloadTarget charSet(String charSet) { @Override public FtpDirDownloadTarget charSet(String charSet) {
return mDelegate.charSet(charSet); return mDelegate.charSet(charSet);
} }
@CheckResult @CheckResult
@Override public FtpDirDownloadTarget login(String userName, String password) { @Override public FtpDirDownloadTarget login(String userName, String password) {
return mDelegate.login(userName, password); return mDelegate.login(userName, password);
} }
@CheckResult @CheckResult
@Override public FtpDirDownloadTarget login(String userName, String password, String account) { @Override public FtpDirDownloadTarget login(String userName, String password, String account) {
return mDelegate.login(userName, password, account); return mDelegate.login(userName, password, account);
} }
@Override public FtpDirDownloadTarget setProxy(Proxy proxy) { @Override public FtpDirDownloadTarget setProxy(Proxy proxy) {
return mDelegate.setProxy(proxy); return mDelegate.setProxy(proxy);
} }
} }

@ -1,127 +1,155 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.download; package com.arialyy.aria.core.download;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.support.annotation.NonNull; import android.support.annotation.NonNull;
import android.text.TextUtils; import android.text.TextUtils;
import com.arialyy.aria.core.common.ftp.FTPSDelegate; import com.arialyy.aria.core.common.ftp.FTPSDelegate;
import com.arialyy.aria.core.common.ftp.FtpDelegate; import com.arialyy.aria.core.common.ftp.FtpDelegate;
import com.arialyy.aria.core.inf.AbsTaskWrapper; import com.arialyy.aria.core.inf.AbsTaskWrapper;
import com.arialyy.aria.core.inf.IFtpTarget; import com.arialyy.aria.core.inf.IFtpTarget;
import com.arialyy.aria.util.ALog; import com.arialyy.aria.util.ALog;
import com.arialyy.aria.util.CommonUtil; import com.arialyy.aria.util.CommonUtil;
import java.net.Proxy; import java.net.Proxy;
/** /**
* Created by lyy on 2016/12/5. * Created by lyy on 2016/12/5.
* https://github.com/AriaLyy/Aria * https://github.com/AriaLyy/Aria
*/ */
public class FtpDownloadTarget extends BaseNormalTarget<FtpDownloadTarget> public class FtpDownloadTarget extends AbsDownloadTarget<FtpDownloadTarget>
implements IFtpTarget<FtpDownloadTarget> { implements IFtpTarget<FtpDownloadTarget> {
private FtpDelegate<FtpDownloadTarget> mDelegate; private FtpDelegate<FtpDownloadTarget> mFtpDelegate;
private DNormalDelegate<FtpDownloadTarget> mNormalDelegate;
public FtpDownloadTarget(DownloadEntity entity, String targetName) {
this(entity.getUrl(), targetName); FtpDownloadTarget(DownloadEntity entity, String targetName) {
} this(entity.getUrl(), targetName);
}
FtpDownloadTarget(String url, String targetName) {
initTarget(url, targetName); FtpDownloadTarget(String url, String targetName) {
init(); mNormalDelegate = new DNormalDelegate<>(this, url, targetName);
} init();
}
private void init() {
int lastIndex = url.lastIndexOf("/"); private void init() {
mEntity.setFileName(url.substring(lastIndex + 1)); int lastIndex = getUrl().lastIndexOf("/");
mTaskWrapper.asFtp().setUrlEntity(CommonUtil.getFtpUrlInfo(url)); mEntity.setFileName(getUrl().substring(lastIndex + 1));
mTaskWrapper.setRequestType(AbsTaskWrapper.D_FTP); getTaskWrapper().asFtp().setUrlEntity(CommonUtil.getFtpUrlInfo(getUrl()));
getTaskWrapper().setRequestType(AbsTaskWrapper.D_FTP);
mDelegate = new FtpDelegate<>(this);
} mFtpDelegate = new FtpDelegate<>(this);
}
/**
* 是否是FTPS协议 /**
* 如果是FTPS协议需要使用{@link FTPSDelegate#setStorePath(String)} {@link FTPSDelegate#setAlias(String)} * 是否是FTPS协议
* 设置证书信息 * 如果是FTPS协议需要使用{@link FTPSDelegate#setStorePath(String)} {@link FTPSDelegate#setAlias(String)}
*/ * 设置证书信息
@CheckResult */
public FTPSDelegate<FtpDownloadTarget> asFtps() { @CheckResult
mTaskWrapper.asFtp().getUrlEntity().isFtps = true; public FTPSDelegate<FtpDownloadTarget> asFtps() {
return new FTPSDelegate<>(this); getTaskWrapper().asFtp().getUrlEntity().isFtps = true;
} return new FTPSDelegate<>(this);
}
@Override protected boolean checkEntity() {
if (mTaskWrapper.asFtp().getUrlEntity().isFtps){ @Override protected boolean checkEntity() {
if (TextUtils.isEmpty(mTaskWrapper.asFtp().getUrlEntity().storePath)){ if (getTaskWrapper().asFtp().getUrlEntity().isFtps) {
ALog.e(TAG, "证书路径为空"); if (TextUtils.isEmpty(getTaskWrapper().asFtp().getUrlEntity().storePath)) {
return false; ALog.e(TAG, "证书路径为空");
} return false;
if (TextUtils.isEmpty(mTaskWrapper.asFtp().getUrlEntity().keyAlias)){ }
ALog.e(TAG, "证书别名为空"); if (TextUtils.isEmpty(getTaskWrapper().asFtp().getUrlEntity().keyAlias)) {
return false; ALog.e(TAG, "证书别名为空");
} return false;
} }
return super.checkEntity(); }
} return mNormalDelegate.checkEntity();
}
/**
* 设置文件保存文件夹路径 @Override public boolean isRunning() {
* return mNormalDelegate.isRunning();
* @param filePath 文件保存路径 }
* @deprecated {@link #setFilePath(String)} 请使用这个api
*/ @Override public boolean taskExists() {
@Deprecated return mNormalDelegate.taskExists();
@CheckResult }
public FtpDownloadTarget setDownloadPath(@NonNull String filePath) {
return setFilePath(filePath); /**
} * 设置文件保存文件夹路径
*
/** * @param filePath 文件保存路径
* 设置文件保存文件夹路径 * @deprecated {@link #setFilePath(String)} 请使用这个api
* 关于文件名 */
* 1如果保存路径是该文件的保存路径/mnt/sdcard/file.zip则使用路径中的文件名file.zip @Deprecated
* 2如果保存路径是文件夹路径/mnt/sdcard/则使用FTP服务器该文件的文件名 @CheckResult
*/ public FtpDownloadTarget setDownloadPath(@NonNull String filePath) {
@CheckResult return setFilePath(filePath);
public FtpDownloadTarget setFilePath(@NonNull String filePath) { }
mTempFilePath = filePath;
return this; /**
} * 设置文件保存文件夹路径
* 关于文件名
@Override protected int getTargetType() { * 1如果保存路径是该文件的保存路径/mnt/sdcard/file.zip则使用路径中的文件名file.zip
return FTP; * 2如果保存路径是文件夹路径/mnt/sdcard/则使用FTP服务器该文件的文件名
} */
@CheckResult
@CheckResult public FtpDownloadTarget setFilePath(@NonNull String filePath) {
@Override public FtpDownloadTarget charSet(String charSet) { setTempFilePath(filePath);
return mDelegate.charSet(charSet); return this;
} }
@CheckResult /**
@Override public FtpDownloadTarget login(String userName, String password) { * 设置文件存储路径如果需要修改新的文件名修改路径便可
return mDelegate.login(userName, password); * 原文件路径 /mnt/sdcard/test.zip
} * 如果需要将test.zip改为game.zip只需要重新设置文件路径为/mnt/sdcard/game.zip
*
@CheckResult * @param filePath 路径必须为文件路径不能为文件夹路径
@Override public FtpDownloadTarget login(String userName, String password, String account) { * @param forceDownload {@code true}强制下载不考虑文件路径是否被占用
return mDelegate.login(userName, password, account); */
} @CheckResult
public FtpDownloadTarget setFilePath(@NonNull String filePath, boolean forceDownload) {
@CheckResult setTempFilePath(filePath);
@Override public FtpDownloadTarget setProxy(Proxy proxy) { setForceDownload(forceDownload);
return mDelegate.setProxy(proxy); return this;
} }
}
@Override public int getTargetType() {
return FTP;
}
@CheckResult
@Override public FtpDownloadTarget charSet(String charSet) {
return mFtpDelegate.charSet(charSet);
}
@CheckResult
@Override public FtpDownloadTarget login(String userName, String password) {
return mFtpDelegate.login(userName, password);
}
@CheckResult
@Override public FtpDownloadTarget login(String userName, String password, String account) {
return mFtpDelegate.login(userName, password, account);
}
@CheckResult
@Override public FtpDownloadTarget setProxy(Proxy proxy) {
return mFtpDelegate.setProxy(proxy);
}
@Override public FtpDownloadTarget updateUrl(String newUrl) {
return mNormalDelegate.updateUrl(newUrl);
}
}

@ -1,312 +1,348 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.inf; package com.arialyy.aria.core.inf;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.text.TextUtils; import android.text.TextUtils;
import com.arialyy.aria.core.AriaManager; import com.arialyy.aria.core.AriaManager;
import com.arialyy.aria.core.command.ICmd; import com.arialyy.aria.core.command.ICmd;
import com.arialyy.aria.core.command.normal.CancelCmd; import com.arialyy.aria.core.command.normal.CancelCmd;
import com.arialyy.aria.core.command.normal.NormalCmdFactory; import com.arialyy.aria.core.command.normal.NormalCmdFactory;
import com.arialyy.aria.core.common.TaskRecord; import com.arialyy.aria.core.common.TaskRecord;
import com.arialyy.aria.core.download.DGTaskWrapper; import com.arialyy.aria.core.download.DGTaskWrapper;
import com.arialyy.aria.core.download.DownloadGroupEntity; import com.arialyy.aria.core.download.DownloadGroupEntity;
import com.arialyy.aria.core.download.DTaskWrapper; import com.arialyy.aria.core.download.DTaskWrapper;
import com.arialyy.aria.core.manager.TaskWrapperManager; import com.arialyy.aria.core.manager.TaskWrapperManager;
import com.arialyy.aria.core.upload.UTaskWrapper; import com.arialyy.aria.core.upload.UTaskWrapper;
import com.arialyy.aria.orm.DbEntity; import com.arialyy.aria.orm.DbEntity;
import com.arialyy.aria.util.ALog; import com.arialyy.aria.util.ALog;
import com.arialyy.aria.util.CommonUtil; import com.arialyy.aria.util.CommonUtil;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
/** /**
* Created by AriaL on 2017/7/3. * Created by AriaL on 2017/7/3.
*/ */
public abstract class AbsTarget<TARGET extends AbsTarget, ENTITY extends AbsEntity, TASK_WRAPPER extends AbsTaskWrapper> public abstract class AbsTarget<TARGET extends AbsTarget, ENTITY extends AbsEntity, TASK_WRAPPER extends AbsTaskWrapper>
implements ITarget { implements ITargetHandler {
protected String TAG;
protected ENTITY mEntity; protected String TAG;
protected TASK_WRAPPER mTaskWrapper; protected ENTITY mEntity;
protected String mTargetName; private TASK_WRAPPER mTaskWrapper;
private String mTargetName;
protected AbsTarget() {
TAG = CommonUtil.getClassName(this); protected AbsTarget() {
} TAG = CommonUtil.getClassName(this);
}
/**
* 重置状态将任务状态设置为未开始状态 /**
* 注意如果在后续方法调用链中没有调用 {@link #start()}{@link #stop()}{@link #cancel()}{@link #resume()} * 重置状态将任务状态设置为未开始状态
* 等操作任务的方法那么你需要调用{@link #save()}才能将修改保存到数据库 * 注意如果在后续方法调用链中没有调用 {@link #start()}{@link #stop()}{@link #cancel()}{@link #resume()}
*/ * 等操作任务的方法那么你需要调用{@link #save()}才能将修改保存到数据库
@CheckResult(suggest = "after use #start()、#stop()、#cancel()、#resume()、#save()?") */
public TARGET resetState() { @CheckResult(suggest = "after use #start()、#stop()、#cancel()、#resume()、#save()?")
mTaskWrapper.getEntity().setState(IEntity.STATE_WAIT); public TARGET resetState() {
mTaskWrapper.setRefreshInfo(true); mTaskWrapper.getEntity().setState(IEntity.STATE_WAIT);
return (TARGET) this; mTaskWrapper.setRefreshInfo(true);
} return (TARGET) this;
}
/**
* 删除记录如果任务正在执行则会删除正在下载的任务 /**
*/ * 删除记录如果任务正在执行则会删除正在下载的任务
public void removeRecord() { */
if (isRunning()) { public void removeRecord() {
ALog.d("AbsTarget", "任务正在下载,即将删除任务"); if (isRunning()) {
cancel(); ALog.d("AbsTarget", "任务正在下载,即将删除任务");
} else { cancel();
if (mEntity instanceof AbsNormalEntity) { } else {
TaskRecord record = if (mEntity instanceof AbsNormalEntity) {
DbEntity.findFirst(TaskRecord.class, "TaskRecord.filePath=?", mTaskWrapper.getKey()); TaskRecord record =
if (record != null) { DbEntity.findFirst(TaskRecord.class, "TaskRecord.filePath=?", mTaskWrapper.getKey());
CommonUtil.delTaskRecord(record, mTaskWrapper.isRemoveFile(), (AbsNormalEntity) mEntity); if (record != null) {
} else { CommonUtil.delTaskRecord(record, mTaskWrapper.isRemoveFile(), (AbsNormalEntity) mEntity);
mEntity.deleteData(); } else {
} mEntity.deleteData();
} else if (mEntity instanceof DownloadGroupEntity) { }
CommonUtil.delGroupTaskRecord(mTaskWrapper.isRemoveFile(), ((DownloadGroupEntity) mEntity)); } else if (mEntity instanceof DownloadGroupEntity) {
} CommonUtil.delGroupTaskRecord(mTaskWrapper.isRemoveFile(), ((DownloadGroupEntity) mEntity));
TaskWrapperManager.getInstance().removeTaskWrapper(mEntity.getKey()); }
} TaskWrapperManager.getInstance().removeTaskWrapper(mEntity.getKey());
} }
}
/**
* 获取任务实体 public ENTITY getEntity() {
*/ return mEntity;
public TASK_WRAPPER getTaskWrapper() { }
return mTaskWrapper;
} public void setTaskWrapper(TASK_WRAPPER mTaskWrapper) {
this.mTaskWrapper = mTaskWrapper;
/** }
* 获取任务进度如果任务存在则返回当前进度
* public String getTargetName() {
* @return 该任务进度 return mTargetName;
*/ }
public long getCurrentProgress() {
return mEntity == null ? -1 : mEntity.getCurrentProgress(); public void setTargetName(String mTargetName) {
} this.mTargetName = mTargetName;
}
/**
* 获取任务文件大小 /**
* * 获取任务实体
* @return 文件大小 */
*/ public TASK_WRAPPER getTaskWrapper() {
public long getSize() { return mTaskWrapper;
return mEntity == null ? 0 : mEntity.getFileSize(); }
}
/**
/** * 获取任务进度如果任务存在则返回当前进度
* 获取单位转换后的文件大小 *
* * @return 该任务进度
* @return 文件大小{@code xxx mb} */
*/ public long getCurrentProgress() {
public String getConvertSize() { return mEntity == null ? -1 : mEntity.getCurrentProgress();
return mEntity == null ? "0b" : CommonUtil.formatFileSize(mEntity.getFileSize()); }
}
/**
/** * 获取任务文件大小
* 设置扩展字段用来保存你的其它数据如果你的数据比较多你可以把你的数据转换为JSON字符串然后再存到Aria中 *
* 注意如果在后续方法调用链中没有调用 {@link #start()}{@link #stop()}{@link #cancel()}{@link #resume()} * @return 文件大小
* 等操作任务的方法那么你需要调用{@link #save()}才能将修改保存到数据库 */
* public long getFileSize() {
* @param str 扩展数据 return mEntity == null ? 0 : mEntity.getFileSize();
*/ }
@CheckResult(suggest = "after use #start()、#stop()、#cancel()、#resume()、#save()?")
public TARGET setExtendField(String str) { /**
if (TextUtils.isEmpty(str)) return (TARGET) this; * 获取单位转换后的文件大小
if (TextUtils.isEmpty(mEntity.getStr()) || !mEntity.getStr().equals(str)) { *
mEntity.setStr(str); * @return 文件大小{@code xxx mb}
} else { */
ALog.e(TAG, "设置扩展字段失败,扩展字段为一致"); public String getConvertFileSize() {
} return mEntity == null ? "0b" : CommonUtil.formatFileSize(mEntity.getFileSize());
}
return (TARGET) this;
} /**
* 设置扩展字段用来保存你的其它数据如果你的数据比较多你可以把你的数据转换为JSON字符串然后再存到Aria中
/** * 注意如果在后续方法调用链中没有调用 {@link #start()}{@link #stop()}{@link #cancel()}{@link #resume()}
* 获取存放的扩展字段 * 等操作任务的方法那么你需要调用{@link #save()}才能将修改保存到数据库
* 设置扩展字段{@link #setExtendField(String)} *
*/ * @param str 扩展数据
public String getExtendField() { */
return mEntity.getStr(); @CheckResult(suggest = "after use #start()、#stop()、#cancel()、#resume()、#save()?")
} public TARGET setExtendField(String str) {
if (TextUtils.isEmpty(str)) return (TARGET) this;
/** if (TextUtils.isEmpty(mEntity.getStr()) || !mEntity.getStr().equals(str)) {
* 获取任务状态 mEntity.setStr(str);
* } else {
* @return {@link IEntity} ALog.e(TAG, "设置扩展字段失败,扩展字段为一致");
*/ }
public int getTaskState() {
return mEntity.getState(); return (TARGET) this;
} }
/** /**
* 获取任务进度百分比 * 获取存放的扩展字段
* * 设置扩展字段{@link #setExtendField(String)}
* @return 返回任务进度 */
*/ public String getExtendField() {
public int getPercent() { return mEntity.getStr();
if (mEntity == null) { }
ALog.e("AbsTarget", "下载管理器中没有该任务");
return 0; /**
} * 获取任务状态
if (mEntity.getFileSize() != 0) { *
return (int) (mEntity.getCurrentProgress() * 100 / mEntity.getFileSize()); * @return {@link IEntity}
} */
return 0; public int getTaskState() {
} return mEntity.getState();
}
/**
* 检查实体是否合法如果实体合法将保存实体到数据库或更新数据库中的实体对象 /**
* * 获取任务进度百分比
* @return {@code true} 合法 *
*/ * @return 返回任务进度
protected abstract boolean checkEntity(); */
public int getPercent() {
protected int checkTaskType() { if (mEntity == null) {
int taskType = 0; ALog.e("AbsTarget", "下载管理器中没有该任务");
if (mTaskWrapper instanceof DTaskWrapper) { return 0;
taskType = ICmd.TASK_TYPE_DOWNLOAD; }
} else if (mTaskWrapper instanceof DGTaskWrapper) { if (mEntity.getFileSize() != 0) {
taskType = ICmd.TASK_TYPE_DOWNLOAD_GROUP; return (int) (mEntity.getCurrentProgress() * 100 / mEntity.getFileSize());
} else if (mTaskWrapper instanceof UTaskWrapper) { }
taskType = ICmd.TASK_TYPE_UPLOAD; return 0;
} }
return taskType;
} /**
* 检查实体是否合法如果实体合法将保存实体到数据库或更新数据库中的实体对象
/** *
* 保存修改 * @return {@code true} 合法
*/ */
@Override public void save() { protected abstract boolean checkEntity();
if (!checkEntity()) {
ALog.e(TAG, "保存修改失败"); protected int checkTaskType() {
} else { int taskType = 0;
ALog.i(TAG, "保存成功"); if (mTaskWrapper instanceof DTaskWrapper) {
} taskType = ICmd.TASK_TYPE_DOWNLOAD;
} } else if (mTaskWrapper instanceof DGTaskWrapper) {
taskType = ICmd.TASK_TYPE_DOWNLOAD_GROUP;
/** } else if (mTaskWrapper instanceof UTaskWrapper) {
* 任务是否在执行 taskType = ICmd.TASK_TYPE_UPLOAD;
* }
* @return {@code true} 任务正在执行 return taskType;
*/ }
public abstract boolean isRunning();
/**
/** * 保存修改
* 任务是否存在 */
* @Override public void save() {
* @return {@code true} 任务存在 if (!checkEntity()) {
*/ ALog.e(TAG, "保存修改失败");
public abstract boolean taskExists(); } else {
ALog.i(TAG, "保存成功");
/** }
* 开始任务 }
*/
@Override public void start() { /**
if (checkEntity()) { * 任务是否在执行
AriaManager.getInstance(AriaManager.APP) *
.setCmd( * @return {@code true} 任务正在执行
CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_START, */
checkTaskType())) public abstract boolean isRunning();
.exe();
} /**
} * 任务是否存在
*
/** * @return {@code true} 任务存在
* 停止任务 */
* public abstract boolean taskExists();
* @see #stop()
*/ /**
@Deprecated public void pause() { * 设置target类型
if (checkEntity()) { *
stop(); * @return {@link #HTTP}{@link #FTP}{@link #GROUP_HTTP}{@link #GROUP_FTP_DIR}
} */
} public abstract int getTargetType();
@Override public void stop() { /**
if (checkEntity()) { * 添加任务
AriaManager.getInstance(AriaManager.APP) */
.setCmd( @Override public void add() {
CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_STOP, checkTaskType())) if (checkEntity()) {
.exe(); AriaManager.getInstance(AriaManager.APP)
} .setCmd(CommonUtil.createNormalCmd(getTaskWrapper(), NormalCmdFactory.TASK_CREATE,
} checkTaskType()))
.exe();
/** }
* 恢复任务 }
*/
@Override public void resume() { /**
if (checkEntity()) { * 开始任务
AriaManager.getInstance(AriaManager.APP) */
.setCmd( @Override public void start() {
CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_START, if (checkEntity()) {
checkTaskType())) AriaManager.getInstance(AriaManager.APP)
.exe(); .setCmd(
} CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_START,
} checkTaskType()))
.exe();
/** }
* 删除任务 }
*/
@Override public void cancel() { /**
if (checkEntity()) { * 停止任务
AriaManager.getInstance(AriaManager.APP) *
.setCmd(CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_CANCEL, * @see #stop()
checkTaskType())) */
.exe(); @Deprecated public void pause() {
} if (checkEntity()) {
} stop();
}
/** }
* 任务重试
*/ @Override public void stop() {
@Override public void reTry() { if (checkEntity()) {
if (checkEntity()) { AriaManager.getInstance(AriaManager.APP)
List<ICmd> cmds = new ArrayList<>(); .setCmd(
int taskType = checkTaskType(); CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_STOP, checkTaskType()))
cmds.add( .exe();
CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_STOP, taskType)); }
cmds.add(CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_START, taskType)); }
AriaManager.getInstance(AriaManager.APP).setCmds(cmds).exe();
} /**
} * 恢复任务
*/
/** @Override public void resume() {
* 删除任务 if (checkEntity()) {
* AriaManager.getInstance(AriaManager.APP)
* @param removeFile {@code true} 不仅删除任务数据库记录还会删除已经删除完成的文件 .setCmd(
* {@code false}如果任务已经完成只删除任务数据库记录 CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_START,
*/ checkTaskType()))
@Override public void cancel(boolean removeFile) { .exe();
if (checkEntity()) { }
CancelCmd cancelCmd = }
(CancelCmd) CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_CANCEL,
checkTaskType()); /**
cancelCmd.removeFile = removeFile; * 删除任务
AriaManager.getInstance(AriaManager.APP).setCmd(cancelCmd).exe(); */
} @Override public void cancel() {
} if (checkEntity()) {
AriaManager.getInstance(AriaManager.APP)
/** .setCmd(CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_CANCEL,
* 重新下载 checkTaskType()))
*/ .exe();
@Override public void reStart() { }
if (checkEntity()) { }
cancel();
start(); /**
} * 任务重试
} */
} @Override public void reTry() {
if (checkEntity()) {
List<ICmd> cmds = new ArrayList<>();
int taskType = checkTaskType();
cmds.add(
CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_STOP, taskType));
cmds.add(CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_START, taskType));
AriaManager.getInstance(AriaManager.APP).setCmds(cmds).exe();
}
}
/**
* 删除任务
*
* @param removeFile {@code true} 不仅删除任务数据库记录还会删除已经删除完成的文件
* {@code false}如果任务已经完成只删除任务数据库记录
*/
@Override public void cancel(boolean removeFile) {
if (checkEntity()) {
CancelCmd cancelCmd =
(CancelCmd) CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_CANCEL,
checkTaskType());
cancelCmd.removeFile = removeFile;
AriaManager.getInstance(AriaManager.APP).setCmd(cancelCmd).exe();
}
}
/**
* 重新下载
*/
@Override public void reStart() {
if (checkEntity()) {
cancel();
start();
}
}
}

@ -1,57 +1,57 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.inf; package com.arialyy.aria.core.inf;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import java.net.Proxy; import java.net.Proxy;
/** /**
* Created by laoyuyu on 2018/3/9. * Created by laoyuyu on 2018/3/9.
*/ */
public interface IFtpTarget<TARGET extends ITarget> { public interface IFtpTarget<TARGET extends ITargetHandler> {
/** /**
* 设置字符编码 * 设置字符编码
*/ */
@CheckResult @CheckResult
TARGET charSet(String charSet); TARGET charSet(String charSet);
/** /**
* ftp 用户登录信 * ftp 用户登录信
* *
* @param userName ftp用户名 * @param userName ftp用户名
* @param password ftp用户密码 * @param password ftp用户密码
*/ */
@CheckResult @CheckResult
TARGET login(String userName, String password); TARGET login(String userName, String password);
/** /**
* ftp 用户登录信息 * ftp 用户登录信息
* *
* @param userName ftp用户名 * @param userName ftp用户名
* @param password ftp用户密码 * @param password ftp用户密码
* @param account ftp账号 * @param account ftp账号
*/ */
@CheckResult @CheckResult
TARGET login(String userName, String password, String account); TARGET login(String userName, String password, String account);
/** /**
* 设置代理 * 设置代理
* *
* @param proxy {@link Proxy} * @param proxy {@link Proxy}
*/ */
@CheckResult @CheckResult
TARGET setProxy(Proxy proxy); TARGET setProxy(Proxy proxy);
} }

@ -1,52 +1,50 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.inf; package com.arialyy.aria.core.inf;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.support.annotation.NonNull; import android.support.annotation.NonNull;
import com.arialyy.aria.core.common.RequestEnum; import java.net.Proxy;
import com.arialyy.aria.core.download.DownloadEntity; import java.util.Map;
import java.net.Proxy;
import java.util.Map; /**
* Created by laoyuyu on 2018/3/9.
/** * HTTP Header功能接口
* Created by laoyuyu on 2018/3/9. */
* HTTP Header功能接口 public interface IHttpHeaderDelegate<TARGET extends ITargetHandler> {
*/
public interface IHttpHeaderDelegate<TARGET extends ITarget> { /**
* 给url请求添加Header数据
/** * 如果新的header数据和数据保存的不一致则更新数据库中对应的header数据
* 给url请求添加Header数据 *
* 如果新的header数据和数据保存的不一致则更新数据库中对应的header数据 * @param key header对应的key
* * @param value header对应的value
* @param key header对应的key */
* @param value header对应的value @CheckResult
*/ TARGET addHeader(@NonNull String key, @NonNull String value);
@CheckResult
TARGET addHeader(@NonNull String key, @NonNull String value); /**
* 给url请求添加一组header数据
/** * 如果新的header数据和数据保存的不一致则更新数据库中对应的header数据
* 给url请求添加一组header数据 *
* 如果新的header数据和数据保存的不一致则更新数据库中对应的header数据 * @param headers 一组http header数据
* */
* @param headers 一组http header数据 @CheckResult
*/ TARGET addHeaders(Map<String, String> headers);
@CheckResult
TARGET addHeaders(Map<String, String> headers); @CheckResult
TARGET setUrlProxy(Proxy proxy);
@CheckResult }
TARGET setUrlProxy(Proxy proxy);
}

@ -1,64 +1,77 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.inf; package com.arialyy.aria.core.inf;
/** /**
* Created by AriaL on 2017/6/29. * Created by AriaL on 2017/6/29.
*/ * 任务接收器的控制接口处理添加任务开始任务停止任务删除任务等功能
public interface ITarget { */
/** public interface ITargetHandler {
* 开始下载 int HTTP = 1;
*/ int FTP = 2;
void start(); //HTTP任务组
int GROUP_HTTP = 3;
/** //FTP文件夹
* 停止下载 int GROUP_FTP_DIR = 4;
*/
void stop(); /**
* 添加任务
/** */
* 恢复下载 void add();
*/
void resume(); /**
* 开始下载
/** */
* 取消下载 void start();
*/
void cancel(); /**
* 停止下载
/** */
* 保存修改 void stop();
*/
void save(); /**
* 恢复下载
/** */
* 删除任务 void resume();
*
* @param removeFile {@code true} 不仅删除任务数据库记录还会删除已经删除完成的文件 /**
* {@code false}如果任务已经完成只删除任务数据库记录 * 取消下载
*/ */
void cancel(boolean removeFile); void cancel();
/** /**
* 任务重试 * 保存修改
*/ */
void reTry(); void save();
/** /**
* 重新下载 * 删除任务
*/ *
void reStart(); * @param removeFile {@code true} 不仅删除任务数据库记录还会删除已经删除完成的文件
} * {@code false}如果任务已经完成只删除任务数据库记录
*/
void cancel(boolean removeFile);
/**
* 任务重试
*/
void reTry();
/**
* 重新下载
*/
void reStart();
}

@ -1,23 +1,24 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.inf; package com.arialyy.aria.core.inf;
/** /**
* 任务信息 * Created by AriaL on 2017/6/29.
*/ * 处理任务头部信息等设置等接口
public interface ITaskDelegate { */
public interface ITargetHeadDelegate {
}
}

@ -0,0 +1,81 @@
/*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
*
* 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.arialyy.aria.core.inf;
/**
* Created by lyy on 2019/4/5.
* 普通任务接收器功能接口
*/
public interface ITargetNormal<TARGET extends AbsTarget> {
/**
* 通过地址初始化target
*
* @param url 下载url上传url
* @param targetName 接收器名称
*/
void initTarget(String url, String targetName);
/**
* 更新下载url
*
* @param newUrl 新的下载url
*/
TARGET updateUrl(String newUrl);
/**
* 获取实体
*/
AbsEntity getEntity();
/**
* 任务是否存在
*
* @return {@code true}任务存在{@code false} 任务不存在
*/
boolean taskExists();
/**
* 任务是否在执行
*
* @return {@code true} 任务正在执行{@code false} 任务没有执行
*/
boolean isRunning();
/**
* 检查下载实体判断实体是否合法 合法标准为
* 1下载路径不为null并且下载路径是正常的http或ftp路径
* 2保存路径不为null并且保存路径是android文件系统路径
* 3保存路径不能重复
*
* @return {@code true}合法
*/
boolean checkEntity();
/**
* 检查并设置普通任务的文件保存路径
*
* @return {@code true}保存路径合法
*/
boolean checkFilePath();
/**
* 检查普通任务的下载地址
*
* @return {@code true}地址合法
*/
boolean checkUrl();
}

@ -1,128 +1,133 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.inf; package com.arialyy.aria.core.inf;
/** import com.arialyy.aria.core.download.DownloadGroupTask;
* Created by lyy on 2017/2/13. import com.arialyy.aria.core.download.DownloadTask;
*/ import com.arialyy.aria.core.upload.UploadTask;
public interface ITask<TASK_WRAPPER extends AbsTaskWrapper> {
/**
/** * Created by lyy on 2017/2/13.
* 普通下载任务 * 任务接口{@link DownloadTask}{@link UploadTask}{@link DownloadGroupTask}
*/ */
int DOWNLOAD = 1; public interface ITask<TASK_WRAPPER extends AbsTaskWrapper> {
/**
* 上传任务 /**
*/ * 普通下载任务
int UPLOAD = 2; */
/** int DOWNLOAD = 1;
* 组合任务 /**
*/ * 上传任务
int DOWNLOAD_GROUP = 3; */
/** int UPLOAD = 2;
* 组合任务的子任务 /**
*/ * 组合任务
int DOWNLOAD_GROUP_SUB = 4; */
/** int DOWNLOAD_GROUP = 3;
* 未知 /**
*/ * 组合任务的子任务
int OTHER = -1; */
int DOWNLOAD_GROUP_SUB = 4;
/** /**
* 获取任务类型 * 未知
* */
* @return {@link #DOWNLOAD}{@link #UPLOAD}{@link #DOWNLOAD_GROUP} int OTHER = -1;
*/
int getTaskType(); /**
* 获取任务类型
/** *
* 获取下载状态 * @return {@link #DOWNLOAD}{@link #UPLOAD}{@link #DOWNLOAD_GROUP}
*/ */
int getState(); int getTaskType();
/** /**
* 唯一标识符DownloadTask 为下载地址UploadTask 为文件路径 * 获取下载状态
*/ */
String getKey(); int getState();
/** /**
* 任务是否正在执行 * 唯一标识符DownloadTask 为下载地址UploadTask 为文件路径
* */
* @return true正在执行 String getKey();
*/
boolean isRunning(); /**
* 任务是否正在执行
/** *
* 获取信息实体 * @return true正在执行
*/ */
TASK_WRAPPER getTaskWrapper(); boolean isRunning();
void start(); /**
* 获取信息实体
/** */
* 停止任务 TASK_WRAPPER getTaskWrapper();
*/
void stop(); void start();
/** /**
* 停止任务 * 停止任务
* */
* @param type {@code 0}默认操作{@code 1}停止任务不自动执行下一任务 void stop();
*/
void stop(int type); /**
* 停止任务
/** *
* 删除任务 * @param type {@code 0}默认操作{@code 1}停止任务不自动执行下一任务
*/ */
void cancel(); void stop(int type);
/** /**
* 原始byte速度 * 删除任务
*/ */
long getSpeed(); void cancel();
/** /**
* 转换单位后的速度 * 原始byte速度
*/ */
String getConvertSpeed(); long getSpeed();
/** /**
* 获取百分比进度 * 转换单位后的速度
*/ */
int getPercent(); String getConvertSpeed();
/** /**
* 原始文件byte长度 * 获取百分比进度
*/ */
long getFileSize(); int getPercent();
/** /**
* 转换单位后的文件长度 * 原始文件byte长度
*/ */
String getConvertFileSize(); long getFileSize();
/** /**
* 获取当前进度 * 转换单位后的文件长度
*/ */
long getCurrentProgress(); String getConvertFileSize();
/** /**
* 获取单位转换后的进度 * 获取当前进度
* */
* @return 返回 3mb long getCurrentProgress();
*/
String getConvertCurrentProgress(); /**
} * 获取单位转换后的进度
*
* @return 返回 3mb
*/
String getConvertCurrentProgress();
}

@ -1,28 +1,47 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.upload; package com.arialyy.aria.core.upload;
import com.arialyy.aria.core.inf.AbsEntity; import com.arialyy.aria.core.inf.AbsTarget;
import com.arialyy.aria.core.inf.AbsTarget;
import com.arialyy.aria.core.inf.AbsTaskWrapper; /**
* Created by AriaL on 2017/6/29.
/** * 普通上传任务接收器
* Created by AriaL on 2017/6/29. */
*/ abstract class AbsUploadTarget<TARGET extends AbsUploadTarget>
abstract class AbsUploadTarget<TARGET extends AbsUploadTarget, ENTITY extends AbsEntity, TASK_ENTITY extends AbsTaskWrapper> extends AbsTarget<TARGET, UploadEntity, UTaskWrapper> {
extends AbsTarget<TARGET, ENTITY, TASK_ENTITY> {
/**
} * 上传路径
*/
private String mTempUrl;
@Override public void setTaskWrapper(UTaskWrapper mTaskWrapper) {
super.setTaskWrapper(mTaskWrapper);
}
String getTempUrl() {
return mTempUrl;
}
void setTempUrl(String tempUrl) {
this.mTempUrl = tempUrl;
}
void setEntity(UploadEntity entity) {
this.mEntity = entity;
}
}

@ -1,146 +1,146 @@
/* ///*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) // * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* // *
* Licensed under the Apache License, Version 2.0 (the "License"); // * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. // * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at // * You may obtain a copy of the License at
* // *
* http://www.apache.org/licenses/LICENSE-2.0 // * http://www.apache.org/licenses/LICENSE-2.0
* // *
* Unless required by applicable law or agreed to in writing, software // * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, // * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and // * See the License for the specific language governing permissions and
* limitations under the License. // * limitations under the License.
*/ // */
package com.arialyy.aria.core.upload; //package com.arialyy.aria.core.upload;
//
import android.support.annotation.CheckResult; //import android.support.annotation.CheckResult;
import android.support.annotation.NonNull; //import android.support.annotation.NonNull;
import android.text.TextUtils; //import android.text.TextUtils;
import com.arialyy.aria.core.manager.TaskWrapperManager; //import com.arialyy.aria.core.manager.TaskWrapperManager;
import com.arialyy.aria.core.queue.UploadTaskQueue; //import com.arialyy.aria.core.queue.UploadTaskQueue;
import com.arialyy.aria.orm.DbEntity; //import com.arialyy.aria.orm.DbEntity;
import com.arialyy.aria.util.ALog; //import com.arialyy.aria.util.ALog;
import java.io.File; //import java.io.File;
//
/** ///**
* Created by AriaL on 2018/3/9. // * Created by AriaL on 2018/3/9.
*/ // */
abstract class BaseNormalTarget<TARGET extends AbsUploadTarget> //abstract class BaseNormalTarget<TARGET extends AbsUploadTarget>
extends AbsUploadTarget<TARGET, UploadEntity, UTaskWrapper> { // extends AbsUploadTarget<TARGET, UploadEntity, UTaskWrapper> {
//
protected String mTempUrl; // protected String mTempUrl;
//
void initTarget(String filePath) { // void initTarget(String filePath) {
mTaskWrapper = // mTaskWrapper =
TaskWrapperManager.getInstance().getHttpTaskWrapper(UTaskWrapper.class, filePath); // TaskWrapperManager.getInstance().getHttpTaskWrapper(UTaskWrapper.class, filePath);
mEntity = mTaskWrapper.getEntity(); // mEntity = mTaskWrapper.getEntity();
File file = new File(filePath); // File file = new File(filePath);
mEntity.setFileName(file.getName()); // mEntity.setFileName(file.getName());
mEntity.setFileSize(file.length()); // mEntity.setFileSize(file.length());
mTempUrl = mEntity.getUrl(); // mTempUrl = mEntity.getUrl();
} // }
//
/** // /**
* 设置上传路径 // * 设置上传路径
* // *
* @param uploadUrl 上传路径 // * @param uploadUrl 上传路径
*/ // */
@CheckResult // @CheckResult
public TARGET setUploadUrl(@NonNull String uploadUrl) { // public TARGET setTempUrl(@NonNull String uploadUrl) {
mTempUrl = uploadUrl; // mTempUrl = uploadUrl;
return (TARGET) this; // return (TARGET) this;
} // }
//
/** // /**
* 上传任务是否存在 // * 上传任务是否存在
* // *
* @return {@code true}存在 // * @return {@code true}存在
*/ // */
@Override public boolean taskExists() { // @Override public boolean taskExists() {
return DbEntity.checkDataExist(UploadEntity.class, "key=?", mEntity.getFilePath()); // return DbEntity.checkDataExist(UploadEntity.class, "key=?", mEntity.getFilePath());
} // }
//
/** // /**
* 是否在上传 // * 是否在上传
* // *
* @deprecated {@link #isRunning()} // * @deprecated {@link #isRunning()}
*/ // */
public boolean isUploading() { // public boolean isUploading() {
return isRunning(); // return isRunning();
} // }
//
@Override public boolean isRunning() { // @Override public boolean isRunning() {
UploadTask task = UploadTaskQueue.getInstance().getTask(mEntity.getKey()); // UploadTask task = UploadTaskQueue.getInstance().getTask(mEntity.getKey());
return task != null && task.isRunning(); // return task != null && task.isRunning();
} // }
//
@Override protected boolean checkEntity() { // @Override protected boolean checkEntity() {
boolean b = checkUrl() && checkFilePath(); // boolean b = checkUrl() && checkFilePath();
if (b) { // if (b) {
mEntity.save(); // mEntity.save();
} // }
if (mTaskWrapper.asFtp().getUrlEntity() != null && mTaskWrapper.asFtp().getUrlEntity().isFtps) { // if (mTaskWrapper.asFtp().getUrlEntity() != null && mTaskWrapper.asFtp().getUrlEntity().isFtps) {
//if (TextUtils.isEmpty(mTaskWrapper.getUrlEntity().storePath)) { // //if (TextUtils.isEmpty(mTaskWrapper.getUrlEntity().storePath)) {
// ALog.e(TAG, "证书路径为空"); // // ALog.e(TAG, "证书路径为空");
// return false; // // return false;
//} // //}
if (TextUtils.isEmpty(mTaskWrapper.asFtp().getUrlEntity().keyAlias)) { // if (TextUtils.isEmpty(mTaskWrapper.asFtp().getUrlEntity().keyAlias)) {
ALog.e(TAG, "证书别名为空"); // ALog.e(TAG, "证书别名为空");
return false; // return false;
} // }
} // }
return b; // return b;
} // }
//
/** // /**
* 检查上传文件路径是否合法 // * 检查上传文件路径是否合法
* // *
* @return {@code true} 合法 // * @return {@code true} 合法
*/ // */
private boolean checkFilePath() { // private boolean checkFilePath() {
String filePath = mEntity.getFilePath(); // String filePath = mEntity.getFilePath();
if (TextUtils.isEmpty(filePath)) { // if (TextUtils.isEmpty(filePath)) {
ALog.e(TAG, "上传失败,文件路径为null"); // ALog.e(TAG, "上传失败,文件路径为null");
return false; // return false;
} else if (!filePath.startsWith("/")) { // } else if (!filePath.startsWith("/")) {
ALog.e(TAG, "上传失败,文件路径【" + filePath + "】不合法"); // ALog.e(TAG, "上传失败,文件路径【" + filePath + "】不合法");
return false; // return false;
} // }
//
File file = new File(mEntity.getFilePath()); // File file = new File(mEntity.getFilePath());
if (!file.exists()) { // if (!file.exists()) {
ALog.e(TAG, "上传失败,文件【" + filePath + "】不存在"); // ALog.e(TAG, "上传失败,文件【" + filePath + "】不存在");
return false; // return false;
} // }
if (file.isDirectory()) { // if (file.isDirectory()) {
ALog.e(TAG, "上传失败,文件【" + filePath + "】不能是文件夹"); // ALog.e(TAG, "上传失败,文件【" + filePath + "】不能是文件夹");
return false; // return false;
} // }
return true; // return true;
} // }
//
/** // /**
* 检查普通任务的下载地址 // * 检查普通任务的下载地址
* // *
* @return {@code true}地址合法 // * @return {@code true}地址合法
*/ // */
protected boolean checkUrl() { // protected boolean checkUrl() {
final String url = mTempUrl; // final String url = mTempUrl;
if (TextUtils.isEmpty(url)) { // if (TextUtils.isEmpty(url)) {
ALog.e(TAG, "上传失败,url为null"); // ALog.e(TAG, "上传失败,url为null");
return false; // return false;
} else if (!url.startsWith("http") && !url.startsWith("ftp")) { // } else if (!url.startsWith("http") && !url.startsWith("ftp")) {
ALog.e(TAG, "上传失败,url【" + url + "】错误"); // ALog.e(TAG, "上传失败,url【" + url + "】错误");
return false; // return false;
} // }
int index = url.indexOf("://"); // int index = url.indexOf("://");
if (index == -1) { // if (index == -1) {
ALog.e(TAG, "上传失败,url【" + url + "】不合法"); // ALog.e(TAG, "上传失败,url【" + url + "】不合法");
return false; // return false;
} // }
mEntity.setUrl(url); // mEntity.setUrl(url);
return true; // return true;
} // }
} //}

@ -1,125 +1,102 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.upload; package com.arialyy.aria.core.upload;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import com.arialyy.aria.core.AriaManager; import com.arialyy.aria.core.FtpUrlEntity;
import com.arialyy.aria.core.FtpUrlEntity; import com.arialyy.aria.core.common.ftp.FTPSDelegate;
import com.arialyy.aria.core.command.normal.NormalCmdFactory; import com.arialyy.aria.core.common.ftp.FtpDelegate;
import com.arialyy.aria.core.common.ftp.FTPSDelegate; import com.arialyy.aria.core.inf.AbsTaskWrapper;
import com.arialyy.aria.core.common.ftp.FtpDelegate; import com.arialyy.aria.core.inf.IFtpTarget;
import com.arialyy.aria.core.common.ftp.FtpTaskDelegate; import java.net.Proxy;
import com.arialyy.aria.core.inf.AbsTaskWrapper;
import com.arialyy.aria.core.inf.IFtpTarget; /**
import com.arialyy.aria.util.CommonUtil; * Created by Aria.Lao on 2017/7/27.
import java.net.Proxy; * ftp单任务上传
*/
/** public class FtpUploadTarget extends AbsUploadTarget<FtpUploadTarget>
* Created by Aria.Lao on 2017/7/27. implements IFtpTarget<FtpUploadTarget> {
* ftp单任务上传 private FtpDelegate<FtpUploadTarget> mFtpDelegate;
*/ private UNormalDelegate<FtpUploadTarget> mNormalDelegate;
public class FtpUploadTarget extends BaseNormalTarget<FtpUploadTarget>
implements IFtpTarget<FtpUploadTarget> { FtpUploadTarget(String filePath, String targetName) {
private FtpDelegate<FtpUploadTarget> mDelegate; mNormalDelegate = new UNormalDelegate<>(this, filePath, targetName);
initTask();
private String mAccount, mUser, mPw; }
private boolean needLogin = false;
private void initTask() {
FtpUploadTarget(String filePath, String targetName) { getTaskWrapper().setRequestType(AbsTaskWrapper.U_FTP);
this.mTargetName = targetName; mFtpDelegate = new FtpDelegate<>(this);
initTask(filePath); }
}
/**
private void initTask(String filePath) { * 设置上传路径
initTarget(filePath); *
mTaskWrapper.setRequestType(AbsTaskWrapper.U_FTP); * @param tempUrl 上传路径
mDelegate = new FtpDelegate<>(this); */
} public FtpUploadTarget setUploadUrl(String tempUrl) {
setTempUrl(tempUrl);
/** return this;
* 添加任务 }
*/
public void add() { /**
if (checkEntity()) { * 是否是FTPS协议
AriaManager.getInstance(AriaManager.APP) * 如果是FTPS协议需要使用{@link FTPSDelegate#setStorePath(String)} {@link FTPSDelegate#setAlias(String)}
.setCmd(CommonUtil.createNormalCmd(mTaskWrapper, NormalCmdFactory.TASK_CREATE, * 设置证书信息
checkTaskType())) */
.exe(); @CheckResult
} public FTPSDelegate<FtpUploadTarget> asFtps() {
} if (getTaskWrapper().asFtp().getUrlEntity() == null) {
FtpUrlEntity urlEntity = new FtpUrlEntity();
@Override protected boolean checkUrl() { urlEntity.isFtps = true;
boolean b = super.checkUrl(); getTaskWrapper().asFtp().setUrlEntity(urlEntity);
if (!b) { }
return false; return new FTPSDelegate<>(this);
} }
FtpTaskDelegate taskDelegate = mTaskWrapper.asFtp();
FtpUrlEntity temp = taskDelegate.getUrlEntity(); @CheckResult
FtpUrlEntity newEntity = CommonUtil.getFtpUrlInfo(mTempUrl); @Override public FtpUploadTarget charSet(String charSet) {
if (temp != null) { //处理FTPS的信息 return mFtpDelegate.charSet(charSet);
newEntity.isFtps = temp.isFtps; }
newEntity.storePass = temp.storePass;
newEntity.keyAlias = temp.keyAlias; @Override public FtpUploadTarget login(String userName, String password) {
newEntity.protocol = temp.protocol; return mFtpDelegate.login(userName, password);
newEntity.storePath = temp.storePath; }
}
taskDelegate.setUrlEntity(newEntity); @Override public FtpUploadTarget login(String userName, String password, String account) {
taskDelegate.getUrlEntity().account = mAccount; return mFtpDelegate.login(userName, password, account);
taskDelegate.getUrlEntity().user = mUser; }
taskDelegate.getUrlEntity().password = mPw;
taskDelegate.getUrlEntity().needLogin = needLogin; @Override public FtpUploadTarget setProxy(Proxy proxy) {
return true; return mFtpDelegate.setProxy(proxy);
} }
/** @Override protected boolean checkEntity() {
* 是否是FTPS协议 return mNormalDelegate.checkEntity();
* 如果是FTPS协议需要使用{@link FTPSDelegate#setStorePath(String)} {@link FTPSDelegate#setAlias(String)} }
* 设置证书信息
*/ @Override public boolean isRunning() {
@CheckResult return mNormalDelegate.isRunning();
public FTPSDelegate<FtpUploadTarget> asFtps() { }
if (mTaskWrapper.asFtp().getUrlEntity() == null) {
FtpUrlEntity urlEntity = new FtpUrlEntity(); @Override public boolean taskExists() {
urlEntity.isFtps = true; return mNormalDelegate.taskExists();
mTaskWrapper.asFtp().setUrlEntity(urlEntity); }
}
return new FTPSDelegate<>(this); @Override public int getTargetType() {
} return FTP;
}
@CheckResult }
@Override public FtpUploadTarget charSet(String charSet) {
return mDelegate.charSet(charSet);
}
@Override public FtpUploadTarget login(String userName, String password) {
needLogin = true;
mUser = userName;
mPw = password;
return this;
}
@Override public FtpUploadTarget login(String userName, String password, String account) {
needLogin = true;
mUser = userName;
mPw = password;
mAccount = account;
return this;
}
@Override public FtpUploadTarget setProxy(Proxy proxy) {
return mDelegate.setProxy(proxy);
}
}

@ -0,0 +1,132 @@
/*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
*
* 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.arialyy.aria.core.upload;
import android.text.TextUtils;
import com.arialyy.aria.core.inf.AbsEntity;
import com.arialyy.aria.core.inf.ITargetNormal;
import com.arialyy.aria.core.manager.TaskWrapperManager;
import com.arialyy.aria.core.queue.UploadTaskQueue;
import com.arialyy.aria.orm.DbEntity;
import com.arialyy.aria.util.ALog;
import java.io.File;
/**
* Created by Aria.Lao on 2019/4/5.
* 普通上传任务通用功能处理
*/
public class UNormalDelegate<TARGET extends AbsUploadTarget> implements ITargetNormal<TARGET> {
private String TAG = "UNormalDelegate";
private UploadEntity mEntity;
private TARGET mTarget;
UNormalDelegate(TARGET target, String filePath, String targetName) {
mTarget = target;
initTarget(filePath, targetName);
}
@Override public void initTarget(String filePath, String targetName) {
UTaskWrapper taskWrapper =
TaskWrapperManager.getInstance().getHttpTaskWrapper(UTaskWrapper.class, filePath);
mEntity = taskWrapper.getEntity();
File file = new File(filePath);
mEntity.setFileName(file.getName());
mEntity.setFileSize(file.length());
mTarget.setTargetName(targetName);
mTarget.setTaskWrapper(taskWrapper);
mTarget.setEntity(mEntity);
mTarget.setTempUrl(mEntity.getUrl());
}
@Override public TARGET updateUrl(String newUrl) {
mTarget.setTempUrl(mEntity.getUrl());
return mTarget;
}
@Override public AbsEntity getEntity() {
return mEntity;
}
@Override public boolean taskExists() {
return DbEntity.checkDataExist(UploadEntity.class, "key=?", mEntity.getFilePath());
}
@Override public boolean isRunning() {
UploadTask task = UploadTaskQueue.getInstance().getTask(mEntity.getKey());
return task != null && task.isRunning();
}
@Override public boolean checkEntity() {
boolean b = checkUrl() && checkFilePath();
if (b) {
mEntity.save();
}
if (mTarget.getTaskWrapper().asFtp().getUrlEntity() != null && mTarget.getTaskWrapper()
.asFtp()
.getUrlEntity().isFtps) {
//if (TextUtils.isEmpty(mTaskWrapper.getUrlEntity().storePath)) {
// ALog.e(TAG, "证书路径为空");
// return false;
//}
if (TextUtils.isEmpty(mTarget.getTaskWrapper().asFtp().getUrlEntity().keyAlias)) {
ALog.e(TAG, "证书别名为空");
return false;
}
}
return b;
}
@Override public boolean checkFilePath() {
String filePath = mEntity.getFilePath();
if (TextUtils.isEmpty(filePath)) {
ALog.e(TAG, "上传失败,文件路径为null");
return false;
} else if (!filePath.startsWith("/")) {
ALog.e(TAG, "上传失败,文件路径【" + filePath + "】不合法");
return false;
}
File file = new File(mEntity.getFilePath());
if (!file.exists()) {
ALog.e(TAG, "上传失败,文件【" + filePath + "】不存在");
return false;
}
if (file.isDirectory()) {
ALog.e(TAG, "上传失败,文件【" + filePath + "】不能是文件夹");
return false;
}
return true;
}
@Override public boolean checkUrl() {
final String url = mTarget.getTempUrl();
if (TextUtils.isEmpty(url)) {
ALog.e(TAG, "上传失败,url为null");
return false;
} else if (!url.startsWith("http") && !url.startsWith("ftp")) {
ALog.e(TAG, "上传失败,url【" + url + "】错误");
return false;
}
int index = url.indexOf("://");
if (index == -1) {
ALog.e(TAG, "上传失败,url【" + url + "】不合法");
return false;
}
mEntity.setUrl(url);
return true;
}
}

@ -1,100 +1,125 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.aria.core.upload; package com.arialyy.aria.core.upload;
import android.support.annotation.CheckResult; import android.support.annotation.CheckResult;
import android.support.annotation.NonNull; import android.support.annotation.NonNull;
import com.arialyy.aria.core.common.http.HttpHeaderDelegate; import com.arialyy.aria.core.common.http.HttpHeaderDelegate;
import com.arialyy.aria.core.common.http.PostDelegate; import com.arialyy.aria.core.common.http.PostDelegate;
import com.arialyy.aria.core.inf.AbsTaskWrapper; import com.arialyy.aria.core.inf.AbsTaskWrapper;
import com.arialyy.aria.core.inf.IHttpHeaderDelegate; import com.arialyy.aria.core.inf.IHttpHeaderDelegate;
import java.net.Proxy; import java.net.Proxy;
import java.util.Map; import java.util.Map;
/** /**
* Created by lyy on 2017/2/28. * Created by lyy on 2017/2/28.
* http 单文件上传 * http 单文件上传
*/ */
public class UploadTarget extends BaseNormalTarget<UploadTarget> public class UploadTarget extends AbsUploadTarget<UploadTarget>
implements IHttpHeaderDelegate<UploadTarget> { implements IHttpHeaderDelegate<UploadTarget> {
private HttpHeaderDelegate<UploadTarget> mDelegate; private HttpHeaderDelegate<UploadTarget> mHeaderDelegate;
private UNormalDelegate<UploadTarget> mNormalDelegate;
UploadTarget(String filePath, String targetName) {
this.mTargetName = targetName; UploadTarget(String filePath, String targetName) {
initTask(filePath); mNormalDelegate = new UNormalDelegate<>(this, filePath, targetName);
} initTask();
}
private void initTask(String filePath) {
initTarget(filePath); private void initTask() {
//http暂时不支持断点上传
//http暂时不支持断点上传 getTaskWrapper().setSupportBP(false);
mTaskWrapper.setSupportBP(false); getTaskWrapper().setRequestType(AbsTaskWrapper.U_HTTP);
mTaskWrapper.setRequestType(AbsTaskWrapper.U_HTTP); mHeaderDelegate = new HttpHeaderDelegate<>(this);
mDelegate = new HttpHeaderDelegate<>(this); }
}
/**
/** * 设置上传路径
* Post处理 *
*/ * @param tempUrl 上传路径
public PostDelegate asPost() { */
return new PostDelegate<>(this); public UploadTarget setUploadUrl(String tempUrl) {
} setTempUrl(tempUrl);
return this;
/** }
* 设置userAgent
*/ /**
@CheckResult * Post处理
public UploadTarget setUserAngent(@NonNull String userAgent) { */
mTaskWrapper.asHttp().setUserAgent(userAgent); public PostDelegate asPost() {
return this; return new PostDelegate<>(this);
} }
/** /**
* 设置服务器需要的附件key * 设置userAgent
* */
* @param attachment 附件key @CheckResult
*/ public UploadTarget setUserAngent(@NonNull String userAgent) {
@CheckResult getTaskWrapper().asHttp().setUserAgent(userAgent);
public UploadTarget setAttachment(@NonNull String attachment) { return this;
mTaskWrapper.asHttp().setAttachment(attachment); }
return this;
} /**
* 设置服务器需要的附件key
/** *
* 设置上传文件类型 * @param attachment 附件key
* */
* @param contentType tipmultipart/form-data @CheckResult
*/ public UploadTarget setAttachment(@NonNull String attachment) {
@CheckResult getTaskWrapper().asHttp().setAttachment(attachment);
public UploadTarget setContentType(String contentType) { return this;
mTaskWrapper.asHttp().setContentType(contentType); }
return this;
} /**
* 设置上传文件类型
@CheckResult *
@Override public UploadTarget addHeader(@NonNull String key, @NonNull String value) { * @param contentType tipmultipart/form-data
return mDelegate.addHeader(key, value); */
} @CheckResult
public UploadTarget setContentType(String contentType) {
@CheckResult getTaskWrapper().asHttp().setContentType(contentType);
@Override public UploadTarget addHeaders(Map<String, String> headers) { return this;
return mDelegate.addHeaders(headers); }
}
@CheckResult
@Override public UploadTarget setUrlProxy(Proxy proxy) { @Override public UploadTarget addHeader(@NonNull String key, @NonNull String value) {
return mDelegate.setUrlProxy(proxy); return mHeaderDelegate.addHeader(key, value);
} }
}
@CheckResult
@Override public UploadTarget addHeaders(Map<String, String> headers) {
return mHeaderDelegate.addHeaders(headers);
}
@Override public UploadTarget setUrlProxy(Proxy proxy) {
return mHeaderDelegate.setUrlProxy(proxy);
}
@Override protected boolean checkEntity() {
return mNormalDelegate.checkEntity();
}
@Override public boolean isRunning() {
return mNormalDelegate.isRunning();
}
@Override public boolean taskExists() {
return mNormalDelegate.taskExists();
}
@Override public int getTargetType() {
return HTTP;
}
}

@ -1,244 +1,244 @@
/* /*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria) * Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.arialyy.simple.core.download; package com.arialyy.simple.core.download;
import android.os.Bundle; import android.os.Bundle;
import android.os.Environment; import android.os.Environment;
import android.support.v7.widget.LinearLayoutManager; import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView; import android.support.v7.widget.RecyclerView;
import android.view.Menu; import android.view.Menu;
import android.view.MenuItem; import android.view.MenuItem;
import android.view.View; import android.view.View;
import android.widget.Button; import android.widget.Button;
import android.widget.TextView; import android.widget.TextView;
import com.arialyy.annotations.Download; import com.arialyy.annotations.Download;
import com.arialyy.aria.core.Aria; import com.arialyy.aria.core.Aria;
import com.arialyy.aria.core.download.DownloadEntity; import com.arialyy.aria.core.download.DownloadEntity;
import com.arialyy.aria.core.download.DownloadTarget; import com.arialyy.aria.core.download.DownloadTarget;
import com.arialyy.aria.core.download.DownloadTask; import com.arialyy.aria.core.download.DownloadTask;
import com.arialyy.aria.core.inf.AbsEntity; import com.arialyy.aria.core.inf.AbsEntity;
import com.arialyy.aria.core.inf.IEntity; import com.arialyy.aria.core.inf.IEntity;
import com.arialyy.frame.util.show.L; import com.arialyy.frame.util.show.L;
import com.arialyy.simple.R; import com.arialyy.simple.R;
import com.arialyy.simple.base.BaseActivity; import com.arialyy.simple.base.BaseActivity;
import com.arialyy.simple.databinding.ActivityHighestPriorityBinding; import com.arialyy.simple.databinding.ActivityHighestPriorityBinding;
import com.arialyy.simple.core.download.multi_download.DownloadAdapter; import com.arialyy.simple.core.download.multi_download.DownloadAdapter;
import com.arialyy.simple.widget.HorizontalProgressBarWithNumber; import com.arialyy.simple.widget.HorizontalProgressBarWithNumber;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
/** /**
* Created by lyy on 2017/6/2. * Created by lyy on 2017/6/2.
* 最高优先级任务Demo * 最高优先级任务Demo
*/ */
public class HighestPriorityActivity extends BaseActivity<ActivityHighestPriorityBinding> { public class HighestPriorityActivity extends BaseActivity<ActivityHighestPriorityBinding> {
private HorizontalProgressBarWithNumber mPb; private HorizontalProgressBarWithNumber mPb;
private Button mStart; private Button mStart;
private Button mStop; private Button mStop;
private Button mCancel; private Button mCancel;
private TextView mSize; private TextView mSize;
private TextView mSpeed; private TextView mSpeed;
private RecyclerView mList; private RecyclerView mList;
private String mTaskName = "光明大陆"; private String mTaskName = "光明大陆";
private static final String DOWNLOAD_URL = private static final String DOWNLOAD_URL =
"https://res5.d.cn/6f78ee3bcfdd033e64892a8553a95814cf5b4a62b12a76d9eb2a694905f0dc30fa5c7f728806a4ee0b3479e7b26a38707dac92b136add91191ac1219aadb4a3aa70bfa6d06d2d8db.apk"; "https://res5.d.cn/6f78ee3bcfdd033e64892a8553a95814cf5b4a62b12a76d9eb2a694905f0dc30fa5c7f728806a4ee0b3479e7b26a38707dac92b136add91191ac1219aadb4a3aa70bfa6d06d2d8db.apk";
private DownloadAdapter mAdapter; private DownloadAdapter mAdapter;
private List<AbsEntity> mData = new ArrayList<>(); private List<AbsEntity> mData = new ArrayList<>();
private Set<String> mRecord = new HashSet<>(); private Set<String> mRecord = new HashSet<>();
@Override protected int setLayoutId() { @Override protected int setLayoutId() {
return R.layout.activity_highest_priority; return R.layout.activity_highest_priority;
} }
@Override protected void init(Bundle savedInstanceState) { @Override protected void init(Bundle savedInstanceState) {
super.init(savedInstanceState); super.init(savedInstanceState);
mPb = findViewById(R.id.progressBar); mPb = findViewById(R.id.progressBar);
mStart = findViewById(R.id.start); mStart = findViewById(R.id.start);
mStop = findViewById(R.id.stop); mStop = findViewById(R.id.stop);
mCancel = findViewById(R.id.cancel); mCancel = findViewById(R.id.cancel);
mSize = findViewById(R.id.size); mSize = findViewById(R.id.size);
mSpeed = findViewById(R.id.speed); mSpeed = findViewById(R.id.speed);
mList = findViewById(R.id.list); mList = findViewById(R.id.list);
setTitle("最高优先级任务"); setTitle("最高优先级任务");
getBinding().setTaskName("任务名:" + mTaskName + " (最高优先级任务)"); getBinding().setTaskName("任务名:" + mTaskName + " (最高优先级任务)");
initWidget(); initWidget();
Aria.download(this).register(); Aria.download(this).register();
} }
private void initWidget() { private void initWidget() {
DownloadTarget target = Aria.download(this).load(DOWNLOAD_URL); DownloadTarget target = Aria.download(this).load(DOWNLOAD_URL);
mPb.setProgress(target.getPercent()); mPb.setProgress(target.getPercent());
if (target.getTaskState() == IEntity.STATE_STOP) { if (target.getTaskState() == IEntity.STATE_STOP) {
mStart.setText("恢复"); mStart.setText("恢复");
mStart.setTextColor(getResources().getColor(android.R.color.holo_blue_light)); mStart.setTextColor(getResources().getColor(android.R.color.holo_blue_light));
setBtState(true); setBtState(true);
} else if (target.isRunning()) { } else if (target.isRunning()) {
setBtState(false); setBtState(false);
} }
mSize.setText(target.getConvertFileSize()); mSize.setText(target.getConvertFileSize());
List<DownloadEntity> temp = Aria.download(this).getTaskList(); List<DownloadEntity> temp = Aria.download(this).getTaskList();
if (temp != null && !temp.isEmpty()) { if (temp != null && !temp.isEmpty()) {
for (DownloadEntity entity : temp) { for (DownloadEntity entity : temp) {
if (entity.getUrl().equals(DOWNLOAD_URL)) continue; if (entity.getUrl().equals(DOWNLOAD_URL)) continue;
mData.add(entity); mData.add(entity);
mRecord.add(entity.getUrl()); mRecord.add(entity.getUrl());
} }
} }
mAdapter = new DownloadAdapter(this, mData); mAdapter = new DownloadAdapter(this, mData);
mList.setLayoutManager(new LinearLayoutManager(this)); mList.setLayoutManager(new LinearLayoutManager(this));
mList.setAdapter(mAdapter); mList.setAdapter(mAdapter);
} }
@Override public boolean onCreateOptionsMenu(Menu menu) { @Override public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_highest_priority, menu); getMenuInflater().inflate(R.menu.menu_highest_priority, menu);
return super.onCreateOptionsMenu(menu); return super.onCreateOptionsMenu(menu);
} }
@Override public boolean onMenuItemClick(MenuItem item) { @Override public boolean onMenuItemClick(MenuItem item) {
switch (item.getItemId()) { switch (item.getItemId()) {
case R.id.add_task: case R.id.add_task:
List<DownloadEntity> temp = getModule(DownloadModule.class).getHighestTestList(); List<DownloadEntity> temp = getModule(DownloadModule.class).getHighestTestList();
for (DownloadEntity entity : temp) { for (DownloadEntity entity : temp) {
String url = entity.getUrl(); String url = entity.getUrl();
if (mRecord.contains(url)) { if (mRecord.contains(url)) {
continue; continue;
} }
mAdapter.addDownloadEntity(entity); mAdapter.addDownloadEntity(entity);
mRecord.add(url); mRecord.add(url);
} }
mAdapter.notifyDataSetChanged(); mAdapter.notifyDataSetChanged();
break; break;
case R.id.help: case R.id.help:
String title = "最高优先级任务介绍"; String title = "最高优先级任务介绍";
String msg = " 将任务设置为最高优先级任务,最高优先级任务有以下特点:\n" String msg = " 将任务设置为最高优先级任务,最高优先级任务有以下特点:\n"
+ " 1、在下载队列中,有且只有一个最高优先级任务\n" + " 1、在下载队列中,有且只有一个最高优先级任务\n"
+ " 2、最高优先级任务会一直存在,直到用户手动暂停或任务完成\n" + " 2、最高优先级任务会一直存在,直到用户手动暂停或任务完成\n"
+ " 3、任务调度器不会暂停最高优先级任务\n" + " 3、任务调度器不会暂停最高优先级任务\n"
+ " 4、用户手动暂停或任务完成后,第二次重新执行该任务,该命令将失效\n" + " 4、用户手动暂停或任务完成后,第二次重新执行该任务,该命令将失效\n"
+ " 5、如果下载队列中已经满了,则会停止队尾的任务,当高优先级任务完成后,该队尾任务将自动执行\n" + " 5、如果下载队列中已经满了,则会停止队尾的任务,当高优先级任务完成后,该队尾任务将自动执行\n"
+ " 6、把任务设置为最高优先级任务后,将自动执行任务,不需要重新调用start()启动任务"; + " 6、把任务设置为最高优先级任务后,将自动执行任务,不需要重新调用start()启动任务";
showMsgDialog(title, msg); showMsgDialog(title, msg);
break; break;
} }
return true; return true;
} }
public void onClick(View view) { public void onClick(View view) {
switch (view.getId()) { switch (view.getId()) {
case R.id.start: case R.id.start:
String text = ((TextView) view).getText().toString(); String text = ((TextView) view).getText().toString();
if (text.equals("重新开始?") || text.equals("开始")) { if (text.equals("重新开始?") || text.equals("开始")) {
Aria.download(this) Aria.download(this)
.load(DOWNLOAD_URL) .load(DOWNLOAD_URL)
.setDownloadPath(Environment.getExternalStorageDirectory().getPath() .setDownloadPath(Environment.getExternalStorageDirectory().getPath()
+ "/Download/" + "/Download/"
+ mTaskName + mTaskName
+ ".apk") + ".apk")
.setHighestPriority(); .setHighestPriority();
} else if (text.equals("恢复")) { } else if (text.equals("恢复")) {
Aria.download(this).load(DOWNLOAD_URL).resume(); Aria.download(this).load(DOWNLOAD_URL).resume();
} }
break; break;
case R.id.stop: case R.id.stop:
Aria.download(this).load(DOWNLOAD_URL).pause(); Aria.download(this).load(DOWNLOAD_URL).pause();
break; break;
case R.id.cancel: case R.id.cancel:
Aria.download(this).load(DOWNLOAD_URL).cancel(); Aria.download(this).load(DOWNLOAD_URL).cancel();
break; break;
} }
} }
/** /**
* 设置start stop 按钮状态 * 设置start stop 按钮状态
*/ */
private void setBtState(boolean state) { private void setBtState(boolean state) {
mStart.setEnabled(state); mStart.setEnabled(state);
mStop.setEnabled(!state); mStop.setEnabled(!state);
} }
@Download.onPre public void onPre(DownloadTask task) { @Download.onPre public void onPre(DownloadTask task) {
mAdapter.updateState(task.getDownloadEntity()); mAdapter.updateState(task.getDownloadEntity());
} }
@Download.onTaskPre public void onTaskPre(DownloadTask task) { @Download.onTaskPre public void onTaskPre(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
mSize.setText(task.getConvertFileSize()); mSize.setText(task.getConvertFileSize());
} }
mAdapter.updateState(task.getDownloadEntity()); mAdapter.updateState(task.getDownloadEntity());
} }
@Download.onTaskStart public void onTaskStart(DownloadTask task) { @Download.onTaskStart public void onTaskStart(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
setBtState(false); setBtState(false);
} }
mAdapter.updateState(task.getDownloadEntity()); mAdapter.updateState(task.getDownloadEntity());
} }
@Download.onTaskResume public void onTaskResume(DownloadTask task) { @Download.onTaskResume public void onTaskResume(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
setBtState(false); setBtState(false);
} }
mAdapter.updateState(task.getDownloadEntity()); mAdapter.updateState(task.getDownloadEntity());
} }
@Download.onTaskStop public void onTaskStop(DownloadTask task) { @Download.onTaskStop public void onTaskStop(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
setBtState(true); setBtState(true);
mStart.setText("恢复"); mStart.setText("恢复");
mStart.setTextColor(getResources().getColor(android.R.color.holo_blue_light)); mStart.setTextColor(getResources().getColor(android.R.color.holo_blue_light));
} }
mAdapter.updateState(task.getDownloadEntity()); mAdapter.updateState(task.getDownloadEntity());
} }
@Download.onTaskCancel public void onTaskCancel(DownloadTask task) { @Download.onTaskCancel public void onTaskCancel(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
setBtState(true); setBtState(true);
mStart.setText("开始"); mStart.setText("开始");
mPb.setProgress(0); mPb.setProgress(0);
} }
mAdapter.updateState(task.getDownloadEntity()); mAdapter.updateState(task.getDownloadEntity());
} }
@Download.onTaskFail public void onTaskFail(DownloadTask task) { @Download.onTaskFail public void onTaskFail(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
setBtState(true); setBtState(true);
} else { } else {
L.d(TAG, "download fail【" + task.getKey() + "】"); L.d(TAG, "download fail【" + task.getKey() + "】");
} }
} }
@Download.onTaskComplete public void onTaskComplete(DownloadTask task) { @Download.onTaskComplete public void onTaskComplete(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
setBtState(true); setBtState(true);
mStart.setText("重新开始"); mStart.setText("重新开始");
mStart.setTextColor(getResources().getColor(android.R.color.holo_green_light)); mStart.setTextColor(getResources().getColor(android.R.color.holo_green_light));
mPb.setProgress(100); mPb.setProgress(100);
} }
mAdapter.updateState(task.getDownloadEntity()); mAdapter.updateState(task.getDownloadEntity());
} }
@Download.onTaskRunning public void onTaskRunning(DownloadTask task) { @Download.onTaskRunning public void onTaskRunning(DownloadTask task) {
if (task.getKey().equals(DOWNLOAD_URL)) { if (task.getKey().equals(DOWNLOAD_URL)) {
mPb.setProgress(task.getPercent()); mPb.setProgress(task.getPercent());
mSpeed.setText(task.getConvertSpeed()); mSpeed.setText(task.getConvertSpeed());
} }
mAdapter.setProgress(task.getDownloadEntity()); mAdapter.setProgress(task.getDownloadEntity());
} }
} }

@ -68,7 +68,7 @@ public class HttpUploadActivity extends BaseActivity<ActivityUploadBinding> {
Aria.upload(HttpUploadActivity.this).load(FILE_PATH) Aria.upload(HttpUploadActivity.this).load(FILE_PATH)
.setUploadUrl( .setUploadUrl(
"http://lib-test.xzxyun.com:8042/Api/upload?data={\"type\":\"1\",\"fileType\":\".apk\"}") "http://lib-test.xzxyun.com:8042/Api/upload?data={\"type\":\"1\",\"fileType\":\".apk\"}")
//.setUploadUrl("http://192.168.1.6:8080/upload/sign_file/").setAttachment("file") //.setTempUrl("http://192.168.1.6:8080/upload/sign_file/").setAttachment("file")
//.addHeader("iplanetdirectorypro", "11a09102fb934ad0bc206f9c611d7933") //.addHeader("iplanetdirectorypro", "11a09102fb934ad0bc206f9c611d7933")
.asPost() .asPost()
.start(); .start();

Loading…
Cancel
Save