云顶彩票 v1.0.0版本的 MD5 值为:63ba5d5275adbaa5b51a7abfd0af75f7

以下内容为反编译后的 ParallelUploader.java 源代码,内容仅作参考


package cn.bmob.v3.datatype.up;

import cn.bmob.v3.exception.BmobException;
import cn.bmob.v3.helper.ErrorCode;
import cn.bmob.v3.util.BLog;
import cn.bmob.v3.util.Base64Coder;
import com.zhy.http.okhttp.OkHttpUtils;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import kotlin.jvm.internal.LongCompanionObject;
import okhttp3.FormBody;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class ParallelUploader {
    private static final String AUTHORIZATION = "Authorization";
    private static final String BACKSLASH = "/";
    private static final int BLOCK_SIZE = 1048576;
    private static final String CONTENT_MD5 = "Content-MD5";
    private static final String CONTENT_SECRET = "Content-Secret";
    private static final String CONTENT_TYPE = "CContent-Type";
    private static final String HOST = "https://v0.api.upyun.com";
    private static final String X_UPYUN_MULTI_DISORDER = "X-Upyun-Multi-Disorder";
    private static final String X_UPYUN_MULTI_LENGTH = "X-Upyun-Multi-Length";
    private static final String X_UPYUN_MULTI_STAGE = "X-Upyun-Multi-Stage";
    private static final String X_UPYUN_MULTI_TYPE = "X-Upyun-Multi-Type";
    private static final String X_UPYUN_MULTI_UUID = "X-Upyun-Multi-UUID";
    private static final String X_UPYUN_PART_ID = "X-Upyun-Part-ID";
    private static final String X_Upyun_Meta_X = "X-Upyun-Meta-X";
    private final String DATE;
    private volatile int blockProgress;
    protected String bucketName;
    private boolean checkMD5;
    private String date;
    private ExecutorService executorService;
    private OkHttpClient mClient;
    private File mFile;
    private UpProgressListener onProgressListener;
    private int paralle;
    protected String password;
    private RandomAccessFile randomAccessFile;
    private String signature;
    private boolean signed;
    private int[] status;
    private int timeout;
    private int totalBlock;
    private String uri;
    private String url;
    protected String userName;
    private String uuid;

    static int access$508(ParallelUploader parallelUploader) {
        int i = parallelUploader.blockProgress;
        parallelUploader.blockProgress = i + 1;
        return i;
    }

    public void setParalle(int i) {
        this.paralle = i;
    }

    public ParallelUploader(String str, String str2, String str3) {
        this.DATE = "Date";
        this.bucketName = null;
        this.userName = null;
        this.password = null;
        this.uri = null;
        this.date = null;
        this.signature = null;
        this.timeout = 20;
        this.executorService = Executors.newSingleThreadExecutor();
        this.paralle = 4;
        this.bucketName = str;
        this.userName = str2;
        this.password = str3;
    }

    public ParallelUploader() {
        this.DATE = "Date";
        this.bucketName = null;
        this.userName = null;
        this.password = null;
        this.uri = null;
        this.date = null;
        this.signature = null;
        this.timeout = 20;
        this.executorService = Executors.newSingleThreadExecutor();
        this.paralle = 4;
    }

    public void setTimeout(int i) {
        this.timeout = i;
    }

    public boolean upload(File file, String str, Map<String, String> map) throws IOException, BmobException, ExecutionException, InterruptedException {
        this.mFile = file;
        this.signed = false;
        this.totalBlock = (int) Math.ceil((file.length() / 1048576.0d) + 2.0d);
        this.randomAccessFile = new RandomAccessFile(this.mFile, "r");
        if (str.startsWith(BACKSLASH)) {
            this.uri = BACKSLASH + this.bucketName + BACKSLASH + URLEncoder.encode(str.substring(1));
        } else {
            this.uri = BACKSLASH + this.bucketName + BACKSLASH + URLEncoder.encode(str);
        }
        this.url = HOST + this.uri;
        this.mClient = new OkHttpClient.Builder().connectTimeout((long) this.timeout, TimeUnit.SECONDS).readTimeout((long) this.timeout, TimeUnit.SECONDS).writeTimeout((long) this.timeout, TimeUnit.SECONDS).build();
        int[] iArr = this.status;
        if (iArr == null || iArr.length != this.totalBlock - 2 || this.uuid == null) {
            this.status = new int[this.totalBlock - 2];
        }
        return startUpload(map);
    }

    public boolean upload(File file, String str, String str2, String str3, Map<String, String> map) throws IOException, BmobException, ExecutionException, InterruptedException {
        this.signed = true;
        this.mFile = file;
        this.uri = str;
        this.date = str2;
        this.signature = str3;
        this.totalBlock = (int) Math.ceil((file.length() / 1048576.0d) + 2.0d);
        this.randomAccessFile = new RandomAccessFile(this.mFile, "r");
        this.url = HOST + str;
        this.mClient = new OkHttpClient.Builder().connectTimeout((long) this.timeout, TimeUnit.SECONDS).readTimeout((long) this.timeout, TimeUnit.SECONDS).writeTimeout((long) this.timeout, TimeUnit.SECONDS).build();
        int[] iArr = this.status;
        if (iArr == null || iArr.length != this.totalBlock - 2 || this.uuid == null) {
            this.status = new int[this.totalBlock - 2];
        }
        return startUpload(map);
    }

    public void upload(final File file, final String str, final Map<String, String> map, final Map<String, Object> map2, final UpCompleteListener upCompleteListener) throws BmobException {
        if (map2 == null) {
            upload(file, str, map, upCompleteListener);
        } else {
            final UpCompleteListener upCompleteListener2 = new UpCompleteListener() {
                @Override
                public void onComplete(final boolean z, final String str2) {
                    AsyncRun.run(new Runnable() {
                        @Override
                        public void run() {
                            if (upCompleteListener != null) {
                                upCompleteListener.onComplete(z, str2);
                            }
                        }
                    });
                }
            };
            this.executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        ParallelUploader.this.upload(file, str, map);
                        String gMTDate = ParallelUploader.this.getGMTDate();
                        ParallelUploader parallelUploader = ParallelUploader.this;
                        String sign = parallelUploader.sign("POST", gMTDate, "/pretreatment/", parallelUploader.userName, ParallelUploader.this.password, null);
                        Map map3 = map2;
                        map3.put(Params.TASKS, Base64Coder.encodeString(map3.get(Params.TASKS).toString()));
                        FormBody.Builder builder = new FormBody.Builder();
                        for (Map.Entry entry : map2.entrySet()) {
                            builder.addEncoded((String) entry.getKey(), entry.getValue().toString());
                        }
                        Response execute = ParallelUploader.this.mClient.newCall(new Request.Builder().url("http://p0.api.upyun.com/pretreatment/").post(builder.build()).header("Date", gMTDate).header(ParallelUploader.AUTHORIZATION, sign).header("User-Agent", UpYunUtils.VERSION).build()).execute();
                        if (!execute.isSuccessful()) {
                            upCompleteListener2.onComplete(false, execute.body().string());
                        } else {
                            upCompleteListener2.onComplete(true, execute.body().string());
                        }
                    } catch (BmobException e) {
                        e.printStackTrace();
                        upCompleteListener2.onComplete(false, e.toString());
                    } catch (IOException e2) {
                        e2.printStackTrace();
                        upCompleteListener2.onComplete(false, e2.toString());
                    } catch (InterruptedException e3) {
                        e3.printStackTrace();
                        upCompleteListener2.onComplete(false, e3.toString());
                    } catch (ExecutionException e4) {
                        e4.printStackTrace();
                        upCompleteListener2.onComplete(false, e4.toString());
                    }
                }
            });
        }
    }

    public void upload(final File file, final String str, final String str2, final String str3, final Map<String, String> map, final UpCompleteListener upCompleteListener) {
        final UpCompleteListener upCompleteListener2 = new UpCompleteListener() {
            @Override
            public void onComplete(final boolean z, final String str4) {
                System.out.println("上传成功后返回内容:" + str4);
                AsyncRun.run(new Runnable() {
                    @Override
                    public void run() {
                        if (upCompleteListener != null) {
                            upCompleteListener.onComplete(z, str4);
                        }
                    }
                });
            }
        };
        this.executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    ParallelUploader.this.upload(file, str, str2, str3, map);
                    upCompleteListener2.onComplete(true, null);
                } catch (BmobException e) {
                    e.printStackTrace();
                    upCompleteListener2.onComplete(false, e.toString());
                } catch (IOException e2) {
                    e2.printStackTrace();
                    upCompleteListener2.onComplete(false, e2.toString());
                } catch (InterruptedException e3) {
                    e3.printStackTrace();
                    upCompleteListener2.onComplete(false, e3.toString());
                } catch (ExecutionException e4) {
                    e4.printStackTrace();
                    upCompleteListener2.onComplete(false, e4.toString());
                }
            }
        });
    }

    public void upload(final File file, final String str, final Map<String, String> map, final UpCompleteListener upCompleteListener) {
        final UpCompleteListener upCompleteListener2 = new UpCompleteListener() {
            @Override
            public void onComplete(final boolean z, final String str2) {
                AsyncRun.run(new Runnable() {
                    @Override
                    public void run() {
                        if (upCompleteListener != null) {
                            upCompleteListener.onComplete(z, str2);
                        }
                    }
                });
            }
        };
        this.executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    ParallelUploader.this.upload(file, str, map);
                    upCompleteListener2.onComplete(true, null);
                } catch (BmobException e) {
                    e.printStackTrace();
                    upCompleteListener2.onComplete(false, e.toString());
                } catch (IOException e2) {
                    e2.printStackTrace();
                    upCompleteListener2.onComplete(false, e2.toString());
                } catch (InterruptedException e3) {
                    e3.printStackTrace();
                    upCompleteListener2.onComplete(false, e3.toString());
                } catch (ExecutionException e4) {
                    e4.printStackTrace();
                    upCompleteListener2.onComplete(false, e4.toString());
                }
            }
        });
    }

    public String getUuid() {
        return this.uuid;
    }

    public void setUuid(String str) {
        this.uuid = str;
    }

    public int[] getStatus() {
        return this.status;
    }

    public void setStatus(int[] iArr) {
        this.status = iArr;
    }

    public void setCheckMD5(boolean z) {
        this.checkMD5 = z;
    }

    public void setOnProgressListener(UpProgressListener upProgressListener) {
        this.onProgressListener = upProgressListener;
    }

    private boolean startUpload(Map<String, String> map) throws IOException, BmobException, ExecutionException, InterruptedException {
        if (this.uuid != null) {
            return processUpload();
        }
        RequestBody create = RequestBody.create((MediaType) null, "");
        String md5 = this.checkMD5 ? UpYunUtils.md5("") : null;
        if (!this.signed) {
            String gMTDate = getGMTDate();
            this.date = gMTDate;
            this.signature = sign(OkHttpUtils.METHOD.PUT, gMTDate, this.uri, this.userName, this.password, md5).trim();
        }
        Request.Builder put = new Request.Builder().url(this.url).header("Date", this.date).header(AUTHORIZATION, this.signature).header(X_UPYUN_MULTI_DISORDER, "true").header(X_UPYUN_MULTI_STAGE, "initiate").header(X_UPYUN_MULTI_TYPE, getMimeType(this.mFile.getPath())).header(X_UPYUN_MULTI_LENGTH, this.mFile.length() + "").header("User-Agent", UpYunUtils.VERSION).put(create);
        if (map != null) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                put.header(entry.getKey(), entry.getValue());
            }
        }
        if (md5 != null) {
            put.header(CONTENT_MD5, md5);
        }
        callRequest(put.build(), 1);
        return processUpload();
    }

    private String getMimeType(String str) {
        String contentTypeFor = URLConnection.getFileNameMap().getContentTypeFor(str);
        if (contentTypeFor == null) {
            contentTypeFor = "application/octet-stream";
        }
        BLog.e("getMimeType:" + contentTypeFor);
        return contentTypeFor;
    }

    private boolean processUpload() throws IOException, BmobException, InterruptedException, ExecutionException {
        this.blockProgress = 0;
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(this.paralle);
        for (int i = 0; i < this.totalBlock - 2; i++) {
            try {
                newFixedThreadPool.submit(uploadBlock(i)).get();
            } catch (InterruptedException e) {
                throw e;
            } catch (ExecutionException e2) {
                throw e2;
            }
        }
        newFixedThreadPool.shutdown();
        try {
            newFixedThreadPool.awaitTermination(LongCompanionObject.MAX_VALUE, TimeUnit.MINUTES);
        } catch (InterruptedException e3) {
            e3.printStackTrace();
        }
        RandomAccessFile randomAccessFile = this.randomAccessFile;
        if (randomAccessFile != null) {
            randomAccessFile.close();
            this.randomAccessFile = null;
        }
        return completeUpload();
    }

    private Runnable uploadBlock(final int i) {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    if (ParallelUploader.this.status[i] == 1) {
                        if (ParallelUploader.this.onProgressListener != null) {
                            ParallelUploader.this.onProgressListener.onRequestProgress(ParallelUploader.this.blockProgress + 2, ParallelUploader.this.totalBlock);
                        }
                        ParallelUploader.access$508(ParallelUploader.this);
                        return;
                    }
                    if (ParallelUploader.this.status[i] == 2) {
                        return;
                    }
                    int[] iArr = ParallelUploader.this.status;
                    int i2 = i;
                    iArr[i2] = 2;
                    byte[] readBlockByIndex = ParallelUploader.this.readBlockByIndex(i2);
                    RequestBody create = RequestBody.create((MediaType) null, readBlockByIndex);
                    String md5 = ParallelUploader.this.checkMD5 ? UpYunUtils.md5(readBlockByIndex) : null;
                    if (!ParallelUploader.this.signed) {
                        ParallelUploader parallelUploader = ParallelUploader.this;
                        parallelUploader.date = parallelUploader.getGMTDate();
                        ParallelUploader parallelUploader2 = ParallelUploader.this;
                        parallelUploader2.signature = parallelUploader2.sign(OkHttpUtils.METHOD.PUT, parallelUploader2.date, ParallelUploader.this.uri, ParallelUploader.this.userName, ParallelUploader.this.password, md5).trim();
                    }
                    Request.Builder put = new Request.Builder().url(ParallelUploader.this.url).header("Date", ParallelUploader.this.date).header(ParallelUploader.AUTHORIZATION, ParallelUploader.this.signature).header(ParallelUploader.X_UPYUN_MULTI_STAGE, "upload").header(ParallelUploader.X_UPYUN_MULTI_UUID, ParallelUploader.this.uuid).header(ParallelUploader.X_UPYUN_PART_ID, i + "").header("User-Agent", UpYunUtils.VERSION).put(create);
                    if (md5 != null) {
                        put.header(ParallelUploader.CONTENT_MD5, md5);
                    }
                    ParallelUploader.this.uploadRequest(put);
                    ParallelUploader.this.status[i] = 1;
                } catch (Exception e) {
                    ParallelUploader.this.status[i] = 3;
                    throw new RuntimeException(e.getMessage());
                }
            }
        };
    }

    public Response uploadRequest(Request.Builder builder) {
        try {
            Response execute = this.mClient.newCall(builder.build()).execute();
            if (!execute.isSuccessful()) {
                int parseInt = Integer.parseInt(execute.header("X-Error-Code", "-1"));
                if (parseInt == 40011061 || parseInt == 40011059) {
                    this.uuid = null;
                }
                throw new RuntimeException(execute.body().string());
            }
            UpProgressListener upProgressListener = this.onProgressListener;
            if (upProgressListener != null) {
                upProgressListener.onRequestProgress(this.blockProgress + 2, this.totalBlock);
            }
            this.blockProgress++;
            return execute;
        } catch (IOException e) {
            throw new RuntimeException(e.toString());
        }
    }

    private boolean completeUpload() throws IOException, BmobException {
        RequestBody create = RequestBody.create((MediaType) null, "");
        String md5 = this.checkMD5 ? UpYunUtils.md5("") : null;
        if (!this.signed) {
            String gMTDate = getGMTDate();
            this.date = gMTDate;
            this.signature = sign(OkHttpUtils.METHOD.PUT, gMTDate, this.uri, this.userName, this.password, md5).trim();
        }
        Request.Builder put = new Request.Builder().url(this.url).header("Date", this.date).header(AUTHORIZATION, this.signature).header(X_UPYUN_MULTI_STAGE, "complete").header(X_UPYUN_MULTI_UUID, this.uuid).header("User-Agent", UpYunUtils.VERSION).put(create);
        if (md5 != null) {
            put.header(CONTENT_MD5, md5);
        }
        callRequest(put.build(), this.totalBlock);
        this.uuid = null;
        this.status = null;
        return true;
    }

    private void callRequest(Request request, int i) throws IOException, BmobException {
        System.out.println("上传接口:" + request.toString());
        Response execute = this.mClient.newCall(request).execute();
        if (!execute.isSuccessful()) {
            throw new BmobException(execute.code(), execute.body().string());
        }
        UpProgressListener upProgressListener = this.onProgressListener;
        if (upProgressListener != null) {
            upProgressListener.onRequestProgress(i, this.totalBlock);
        }
        this.uuid = execute.header(X_UPYUN_MULTI_UUID, "");
    }

    public String getGMTDate() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US);
        simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
        return simpleDateFormat.format(new Date());
    }

    public String sign(String str, String str2, String str3, String str4, String str5, String str6) throws BmobException {
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        sb.append("&");
        sb.append(str3);
        sb.append("&");
        sb.append(str2);
        if (str6 != null) {
            sb.append("&");
            sb.append(str6);
        }
        try {
            byte[] calculateRFC2104HMACRaw = UpYunUtils.calculateRFC2104HMACRaw(str5, sb.toString().trim());
            if (calculateRFC2104HMACRaw == null) {
                return null;
            }
            return "UPYUN " + str4 + ":" + Base64Coder.encodeLines(calculateRFC2104HMACRaw);
        } catch (Exception unused) {
            throw new BmobException(ErrorCode.E9015, "calculate SHA1 wrong.");
        }
    }

    public byte[] readBlockByIndex(int i) throws IOException {
        byte[] bArr = new byte[1048576];
        this.randomAccessFile.seek(i * 1048576);
        int read = this.randomAccessFile.read(bArr, 0, 1048576);
        if (read >= 1048576) {
            return bArr;
        }
        byte[] bArr2 = new byte[read];
        System.arraycopy(bArr, 0, bArr2, 0, read);
        return bArr2;
    }

    public class Params {
        public static final String ACCEPT = "accept";
        public static final String AVOPTS = "avopts";
        public static final String BUCKET_NAME = "bucket_name";
        public static final String DESCRIPTION = "description";
        public static final String INFO = "info";
        public static final String NOTIFY_URL = "notify_url";
        public static final String PATH = "path";
        public static final String RETURN_INFO = "return_info";
        public static final String SAVE_AS = "save_as";
        public static final String SIGNATURE = "signature";
        public static final String SOURCE = "source";
        public static final String STATUS_CODE = "status_code";
        public static final String TASKS = "tasks";
        public static final String TASK_ID = "task_id";
        public static final String TASK_IDS = "task_ids";
        public static final String TIMESTAMP = "timestamp";
        public static final String TYPE = "type";

        public Params() {
        }
    }
}