流利说-英语 v8.47.26版本的 MD5 值为：0079dce5ff96e6cdbc95c261b3f51387

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

package com.herewhite.sdk;

import com.google.gson.e;
import com.google.gson.m;
import com.herewhite.sdk.domain.ConversionInfo;
import com.herewhite.sdk.domain.ConvertErrorCode;
import com.herewhite.sdk.domain.ConvertException;
import com.herewhite.sdk.domain.ConvertedFiles;
import com.herewhite.sdk.domain.ConverterStatus;
import com.herewhite.sdk.domain.PptPage;
import com.herewhite.sdk.domain.Scene;
import com.qiniu.android.http.Client;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class Converter {
    static final String PPT_ORIGIN = "https://cloudcapiv4.herewhite.com";
    private Date beginDate;
    OkHttpClient client;
    private boolean converting;
    private e gson;
    private long interval;
    private String roomToken;
    private ConverterStatus status;
    private String taskId;
    private long timeout;
    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    static ExecutorService poolExecutor = Executors.newSingleThreadExecutor();

    public interface CheckCallback {
        void onCheckFailure(Exception exc);

        void onCheckResponse(ConversionInfo conversionInfo);
    }

    public interface ConvertCallback {
        void onConvertFailure(ConvertException convertException);

        void onConvertFinish(ConversionInfo conversionInfo);

        void onConvertProgress(Double d, ConversionInfo conversionInfo);
    }

    public enum ConvertType {
        Unknown,
        Static,
        Dynamic
    }

    public String getRoomToken() {
        return this.roomToken;
    }

    public String getTaskId() {
        return this.taskId;
    }

    public long getInterval() {
        return this.interval;
    }

    public void setInterval(long j) {
        this.interval = j;
    }

    public long getTimeout() {
        return this.timeout;
    }

    public void setTimeout(long j) {
        this.timeout = j;
    }

    public ConverterStatus getStatus() {
        return this.status;
    }

    public Converter(String str) {
        this(str, 15000L, 180000L);
    }

    public Converter(String str, long j, long j2) {
        this.converting = true;
        this.client = new OkHttpClient();
        this.roomToken = str;
        this.gson = new e();
        this.status = ConverterStatus.Idle;
        this.interval = j;
        this.timeout = j2;
    }

    public void startConvertTask(final String str, final ConvertType convertType, final ConverterCallbacks converterCallbacks) {
        this.beginDate = new Date();
        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                final CountDownLatch countDownLatch = new CountDownLatch(1);
                this.createConvertTask(str, convertType, new Callback() {
                    @Override
                    public void onFailure(Call call, IOException iOException) {
                        this.status = ConverterStatus.CreateFail;
                        converterCallbacks.onFailure(new ConvertException(ConvertErrorCode.CreatedFail, iOException));
                        countDownLatch.countDown();
                    }

                    @Override
                    public void onResponse(Call call, Response response) throws IOException {
                        m mVar = (m) Converter.this.gson.fromJson(response.body().string(), m.class);
                        if (response.code() == 200) {
                            if (mVar.dM("msg").dK("succeed").getAsBoolean()) {
                                this.status = ConverterStatus.Created;
                                this.taskId = mVar.dM("msg").dJ("taskUUID").TT();
                            } else {
                                this.status = ConverterStatus.CreateFail;
                                converterCallbacks.onFailure(new ConvertException(ConvertErrorCode.CreatedFail, Converter.this.gson.a(mVar)));
                            }
                        } else {
                            this.status = ConverterStatus.CreateFail;
                            converterCallbacks.onFailure(new ConvertException(ConvertErrorCode.ConvertFail, Converter.this.gson.a(mVar)));
                        }
                        countDownLatch.countDown();
                    }
                });
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (this.status == ConverterStatus.CreateFail) {
                    return;
                }
                this.polling(Converter.this.taskId, convertType, new ConvertCallback() {
                    @Override
                    public void onConvertProgress(Double d, ConversionInfo conversionInfo) {
                        converterCallbacks.onProgress(d, conversionInfo);
                    }

                    @Override
                    public void onConvertFinish(ConversionInfo conversionInfo) {
                        this.status = ConverterStatus.Success;
                        converterCallbacks.onFinish(this.getPpt(conversionInfo, convertType), conversionInfo);
                    }

                    @Override
                    public void onConvertFailure(ConvertException convertException) {
                        converterCallbacks.onFailure(convertException);
                    }
                });
            }
        });
    }

    public void createConvertTask(String str, ConvertType convertType, Callback callback) {
        String str2 = convertType.equals(ConvertType.Dynamic) ? "dynamic_conversion" : "static_conversion";
        HashMap hashMap = new HashMap();
        hashMap.put("sourceUrl", str);
        hashMap.put("serviceType", str2);
        this.client.newCall(new Request.Builder().url("https://cloudcapiv4.herewhite.com/services/conversion/tasks?roomToken=" + this.roomToken).header(Client.ContentTypeHeader, Client.JsonMime).header("Accept", Client.JsonMime).post(RequestBody.create(JSON, this.gson.aB(hashMap))).build()).enqueue(callback);
    }

    public void polling(String str, ConvertType convertType, final ConvertCallback convertCallback) {
        boolean z = this.status == ConverterStatus.Timeout || this.status == ConverterStatus.CheckingFail || this.status == ConverterStatus.GetDynamicFail;
        if (this.status == ConverterStatus.Created || z) {
            Date date = new Date(this.beginDate.getTime() + this.timeout);
            while (this.converting && date.after(new Date())) {
                final CountDownLatch countDownLatch = new CountDownLatch(1);
                this.status = ConverterStatus.Checking;
                checkProgress(str, convertType, new CheckCallback() {
                    @Override
                    public void onCheckResponse(ConversionInfo conversionInfo) {
                        ConversionInfo.ServerConversionStatus convertStatus = conversionInfo.getConvertStatus();
                        if (convertStatus == ConversionInfo.ServerConversionStatus.Fail || convertStatus == ConversionInfo.ServerConversionStatus.NotFound) {
                            Converter.this.converting = false;
                            this.status = ConverterStatus.Fail;
                            convertCallback.onConvertFailure(new ConvertException(convertStatus == ConversionInfo.ServerConversionStatus.Fail ? ConvertErrorCode.ConvertFail : ConvertErrorCode.NotFound, conversionInfo.getReason()));
                        } else if (convertStatus == ConversionInfo.ServerConversionStatus.Finished) {
                            Converter.this.converting = false;
                            convertCallback.onConvertFinish(conversionInfo);
                        } else {
                            this.status = ConverterStatus.WaitingForNextCheck;
                            convertCallback.onConvertProgress(conversionInfo.getConvertedPercentage(), conversionInfo);
                        }
                        try {
                            Thread.sleep(Converter.this.interval);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        countDownLatch.countDown();
                    }

                    @Override
                    public void onCheckFailure(Exception exc) {
                        convertCallback.onConvertFailure(new ConvertException(ConvertErrorCode.CheckFail));
                        Converter.this.converting = false;
                        countDownLatch.countDown();
                    }
                });
                try {
                    countDownLatch.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (this.status == ConverterStatus.WaitingForNextCheck) {
                this.status = ConverterStatus.Timeout;
                convertCallback.onConvertFailure(new ConvertException(ConvertErrorCode.CheckTimeout));
            }
        }
    }

    private void checkProgress(String str, ConvertType convertType, final CheckCallback checkCallback) {
        String str2 = convertType.equals(ConvertType.Dynamic) ? "dynamic_conversion" : "static_conversion";
        Call newCall = this.client.newCall(new Request.Builder().url("https://cloudcapiv4.herewhite.com/services/conversion/tasks/" + str + "/progress?roomToken=" + this.roomToken + "&serviceType=" + str2).header(Client.ContentTypeHeader, Client.JsonMime).header("Accept", Client.JsonMime).build());
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        this.status = ConverterStatus.Checking;
        newCall.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException iOException) {
                checkCallback.onCheckFailure(iOException);
                this.status = ConverterStatus.CheckingFail;
                countDownLatch.countDown();
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                m mVar = (m) Converter.this.gson.fromJson(response.body().string(), m.class);
                if (response.code() == 200) {
                    checkCallback.onCheckResponse((ConversionInfo) Converter.this.gson.fromJson(Converter.this.gson.a(mVar.dM("msg").dM("task")), ConversionInfo.class));
                } else {
                    checkCallback.onCheckFailure(new ConvertException(ConvertErrorCode.ConvertFail, Converter.this.gson.a(mVar)));
                }
                countDownLatch.countDown();
            }
        });
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public ConvertedFiles getPpt(ConversionInfo conversionInfo, ConvertType convertType) {
        int length = conversionInfo.getConvertedFileList().length;
        String[] strArr = new String[length];
        Scene[] sceneArr = new Scene[length];
        ConvertedFiles convertedFiles = new ConvertedFiles();
        convertedFiles.setTaskId(this.taskId);
        convertedFiles.setType(convertType(convertType));
        int i = 0;
        while (i < length) {
            PptPage pptPage = conversionInfo.getConvertedFileList()[i];
            pptPage.setSrc(conversionInfo.getPrefix() + pptPage.getSrc());
            strArr[i] = pptPage.getSrc();
            int i2 = i + 1;
            sceneArr[i] = new Scene(String.valueOf(i2), pptPage);
            i = i2;
        }
        convertedFiles.setSlideURLs(strArr);
        convertedFiles.setScenes(sceneArr);
        return convertedFiles;
    }

    private com.herewhite.sdk.converter.ConvertType convertType(ConvertType convertType) {
        if (convertType == ConvertType.Static) {
            return com.herewhite.sdk.converter.ConvertType.Static;
        }
        return com.herewhite.sdk.converter.ConvertType.Dynamic;
    }
}