IPrint/app/src/main/java/epson/print/copy/Component/ecopycomponent/RemoteCopyTask.java

package epson.print.copy.Component.ecopycomponent;

import android.content.Context;
import android.os.AsyncTask;

import com.epson.iprint.prtlogger.Analytics;
import com.epson.iprint.prtlogger.CommonLog;
import com.epson.iprint.prtlogger.PrintLog;
import epson.print.copy.Component.ecopycomponent.ECopyComponent;
import epson.print.copy.Component.eremoteoperation.ERemoteCopy;
import epson.print.copy.Component.eremoteoperation.ERemoteOperation;
import epson.print.copy.Component.eremoteoperation.ERemotePrinter;
import java.util.ArrayList;
import java.util.Iterator;

class RemoteCopyTask extends AsyncTask<Void, Progress, Result> implements ECopyComponent.ITask {
    ERemoteCopy.IRemoteCancelParameter cancelParameter;
    boolean cancelRequested;
    String clientID;
    CopyMode copyMode;
    String jobToken;
    private Context mContext;
    private CopyParams mCopyParams;
    ERemoteCopy operation;
    ECopyOptionContext optionContext;
    Progress progress;
    String recoverJobToken;
    ECopyComponent.ICopyStatusListener statusListener;
    ERemoteCopy.IRemoteCopyStatusParameter statusParameter;
    ECopyComponent.ICopySystemSettings systemSettings;

    public enum CopyMode {
        Copy,
        Recover
    }

    class Progress {
        int currentPages;
        ECopyComponent.ICopyInvalidateResumeRequest resumeRequest;
        ECopyComponent.ICopyResumeRequest.ResumeState resumeState;
        ECopyComponent.ICopyStatusListener.CopyTaskProgress taskProgress;
        int totalPages;

        Progress() {
        }
    }

    class Result {
        ECopyComponent.ICopyStatusListener.CopyTaskResult taskResult;

        private void setResult(ERemoteOperation.ERemoteParam eRemoteParam) {
            switch (eRemoteParam) {
                case none:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.Succeed;
                    return;
                case success:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.Succeed;
                    return;
                case canceled:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.Canceled;
                    return;
                case busy:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.Busy;
                    return;
                case illegal_combination:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.ErrorOther;
                    return;
                case memory_full:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.ErrorOther;
                    return;
                case remove_adf_paper:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.RemoveAdfPaper;
                    return;
                case set_adf_paper:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.ErrorOther;
                    return;
                case document_error:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.ErrorOther;
                    return;
                case x_failed_communication:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.ErrorCommunication;
                    return;
                case unknown_token:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.ErrorOther;
                    return;
                default:
                    this.taskResult = ECopyComponent.ICopyStatusListener.CopyTaskResult.ErrorOther;
                    return;
            }
        }

        public Result(ERemoteOperation.ERemoteParam eRemoteParam) {
            setResult(eRemoteParam);
        }

        public Result(ERemoteOperation.ERemoteReasonResult eRemoteReasonResult) {
            if (eRemoteReasonResult.isNull(ERemoteOperation.ERemoteParam.success)) {
                setResult(ERemoteOperation.ERemoteParam.x_failed_communication);
            } else {
                setResult(eRemoteReasonResult.reason());
            }
        }
    }

    static ECopyComponent.ICopyResumeRequest.StopReason getPrinterStopReason(ArrayList<ERemoteOperation.ERemoteParam> arrayList) {
        ECopyComponent.ICopyResumeRequest.StopReason stopReason = ECopyComponent.ICopyResumeRequest.StopReason.None;
        stopReason.string = ERemoteOperation.ERemoteParam.none.string;
        Iterator<ERemoteOperation.ERemoteParam> it = arrayList.iterator();
        while (it.hasNext()) {
            ERemoteOperation.ERemoteParam next = it.next();
            boolean z = true;
            switch (next) {
                case marker_supply_empty_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterMarkerSupplyEmptyError;
                    break;
                case marker_waste_full_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterMarkerWasteFullError;
                    break;
                case media_jam_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterMediaJamError;
                    break;
                case media_empty_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterMediaEmptyError;
                    break;
                case input_tray_missing_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterOtherError;
                    break;
                case cover_open_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterCoverOpenError;
                    break;
                case output_area_full_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterOutputAreaFullError;
                    break;
                case other_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.PrinterOtherError;
                    break;
                default:
                    z = false;
                    break;
            }
            if (z) {
                stopReason.string = next.string;
            }
        }
        return stopReason;
    }

    static ECopyComponent.ICopyResumeRequest.StopReason getScannerStopReason(ArrayList<ERemoteOperation.ERemoteParam> arrayList) {
        ECopyComponent.ICopyResumeRequest.StopReason stopReason = ECopyComponent.ICopyResumeRequest.StopReason.None;
        stopReason.string = ERemoteOperation.ERemoteParam.none.string;
        Iterator<ERemoteOperation.ERemoteParam> it = arrayList.iterator();
        while (it.hasNext()) {
            ERemoteOperation.ERemoteParam next = it.next();
            switch (next) {
                case media_jam_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.ScannerOtherError;
                    break;
                case media_empty_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.ScannerOtherError;
                    break;
                case other_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.ScannerOtherError;
                    break;
                case media_size_missmatch_error:
                    stopReason = ECopyComponent.ICopyResumeRequest.StopReason.ScannerOtherError;
                    break;
            }
            stopReason.string = next.string;
        }
        return stopReason;
    }

    public RemoteCopyTask(CopyMode copyMode2, String str, ECopyComponent.ICopyStatusListener iCopyStatusListener, Context context) {
        this.operation = new ERemoteCopy();
        this.progress = new Progress();
        this.statusListener = iCopyStatusListener;
        this.copyMode = copyMode2;
        this.recoverJobToken = str;
        this.mContext = context;
    }

    public RemoteCopyTask(CopyMode copyMode2, ECopyComponent.ICopyStatusListener iCopyStatusListener, Context context) {
        this(copyMode2, "", iCopyStatusListener, context);
    }

    public ECopyComponent.ICopyCancelRequest start() {
        super.execute(new Void[0]);
        return new ECopyComponent.ICopyCancelRequest() {
            public void cancel() {
                synchronized (this) {
                    RemoteCopyTask.this.cancelRequested = true;
                }
            }
        };
    }

    public void setSystemSettings(ECopyComponent.ICopySystemSettings iCopySystemSettings) {
        this.systemSettings = iCopySystemSettings;
    }

    public void setRequestConnectionTimeout(int i) {
        this.operation.setRequestConnectionTimeout(i);
    }

    public void setClientID(String str) {
        this.clientID = str;
    }

    public void setOptionContext(ECopyOptionContext eCopyOptionContext) {
        this.optionContext = eCopyOptionContext;
    }

    protected void onPreExecute() {
        this.cancelParameter = new ERemoteCopy.IRemoteCancelParameter() {
            public String client_id() {
                return RemoteCopyTask.this.clientID;
            }

            public String job_token() {
                return RemoteCopyTask.this.jobToken;
            }
        };
        this.statusParameter = new ERemoteCopy.IRemoteCopyStatusParameter() {
            public String client_id() {
                return RemoteCopyTask.this.clientID;
            }

            public String job_token() {
                return RemoteCopyTask.this.jobToken;
            }

            public ArrayList<ERemoteOperation.ERemoteParam> keys() {
                ArrayList<ERemoteOperation.ERemoteParam> arrayList = new ArrayList<>();
                arrayList.add(ERemoteOperation.ERemoteParam.job_state);
                arrayList.add(ERemoteOperation.ERemoteParam.job_result);
                arrayList.add(ERemoteOperation.ERemoteParam.job_tokens);
                arrayList.add(ERemoteOperation.ERemoteParam.printer_state);
                arrayList.add(ERemoteOperation.ERemoteParam.printer_state_reasons);
                arrayList.add(ERemoteOperation.ERemoteParam.scanner_state);
                arrayList.add(ERemoteOperation.ERemoteParam.scanner_state_reasons);
                arrayList.add(ERemoteOperation.ERemoteParam.job_print_total_pages);
                arrayList.add(ERemoteOperation.ERemoteParam.job_print_current_pages);
                return arrayList;
            }
        };
        this.statusListener.onStarted(ECopyComponent.ICopyStatusListener.CopyTaskType.Copy);
    }

    protected void onProgressUpdate(Progress... progressArr) {
        Progress progress2 = progressArr[0];
        this.statusListener.onProcessed(ECopyComponent.ICopyStatusListener.CopyTaskType.Copy, progress2.totalPages, progress2.currentPages, progress2.taskProgress, progress2.resumeRequest);
    }

    private void resumeNotify(ECopyComponent.ICopyResumeRequest.ResumeState resumeState) {
        synchronized (this.progress) {
            this.progress.resumeState = resumeState;
            this.progress.notify();
        }
    }

    private void resumeExecute() {
        ERemoteCopy.ERemoteCopyStatusResult status;
        if (this.progress.resumeRequest != null) {
            synchronized (this.progress) {
                while (true) {
                    try {
                        if (this.progress.resumeState == null) {
                            this.progress.wait(1000);
                            switch (this.operation.getStatus(this.statusParameter).printer_state()) {
                                case idle:
                                    this.progress.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Processing;
                                    publishProgress(new Progress[]{this.progress});
                                    resumeNotify(ECopyComponent.ICopyResumeRequest.ResumeState.Cancel);
                                    continue;
                                case processing:
                                    this.progress.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Processing;
                                    publishProgress(new Progress[]{this.progress});
                                    resumeNotify(ECopyComponent.ICopyResumeRequest.ResumeState.ClearError);
                                    continue;
                                case stopped:
                                    if (this.progress.resumeRequest.getStopReason().equals(getPrinterStopReason(status.printer_state_reasons()))) {
                                        continue;
                                    } else {
                                        return;
                                    }
                                default:
                                    continue;
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        switch (this.progress.resumeState) {
                            case ClearError:
                                ERemotePrinter eRemotePrinter = new ERemotePrinter();
                                eRemotePrinter.setHostIP(this.operation.getHostIP());
                                eRemotePrinter.setRequestConnectionTimeout(this.operation.getRequestConnectionTimeout());
                                eRemotePrinter.clearError(new ERemoteOperation.IRemoteOperationParameter() {
                                    public String client_id() {
                                        return RemoteCopyTask.this.clientID;
                                    }
                                });
                                for (int i = 0; i < 6 && !this.operation.getStatus(this.statusParameter).printer_state().equals(ERemoteOperation.ERemoteParam.processing); i++) {
                                    try {
                                        Thread.sleep(5000);
                                    } catch (InterruptedException e2) {
                                        e2.printStackTrace();
                                    }
                                }
                                break;
                            case Cancel:
                                this.cancelRequested = true;
                                break;
                            case NextPageReady:
                            case NextPageNotExist:
                                boolean success = this.operation.documentChanged(new ERemoteCopy.IRemoteCopyDocumentChangedParameter() {
                                    public String client_id() {
                                        return RemoteCopyTask.this.clientID;
                                    }

                                    public String job_token() {
                                        return RemoteCopyTask.this.jobToken;
                                    }

                                    public boolean next_document() {
                                        return RemoteCopyTask.this.progress.resumeState == ECopyComponent.ICopyResumeRequest.ResumeState.NextPageReady;
                                    }
                                }).success();
                                break;
                        }
                        Progress progress2 = this.progress;
                        progress2.resumeState = null;
                        progress2.resumeRequest = null;
                        return;
                    }
                }
            }
        }
    }

    /* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r0v1, resolved type: epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyStatusResult} */
    /* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r0v5, resolved type: epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyResult} */
    /* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r0v6, resolved type: epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyStatusResult} */
    /* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r0v7, resolved type: epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyStatusResult} */
    /* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r0v8, resolved type: epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyStatusResult} */
    /* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r0v9, resolved type: epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyStatusResult} */
    /* access modifiers changed from: package-private */
    /* JADX WARNING: Multi-variable type inference failed */
    /* Code decompiled incorrectly, please refer to instructions dump. */
    public epson.print.copy.Component.eremoteoperation.ERemoteOperation.ERemoteReasonResult startCopy() {
        /*
            r4 = this;
            epson.print.copy.Component.ecopycomponent.RemoteCopyTask$CopyMode r0 = r4.copyMode
            epson.print.copy.Component.ecopycomponent.RemoteCopyTask$CopyMode r1 = epson.print.copy.Component.ecopycomponent.RemoteCopyTask.CopyMode.Copy
            if (r0 != r1) goto L_0x0024
            epson.print.copy.Component.ecopycomponent.RemoteCopyTask$6 r0 = new epson.print.copy.Component.ecopycomponent.RemoteCopyTask$6
            r0.<init>()
            epson.print.copy.Component.ecopycomponent.CopyParams r1 = r4.getCopyParams(r0)
            r4.mCopyParams = r1
            epson.print.copy.Component.eremoteoperation.ERemoteCopy r1 = r4.operation
            epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyResult r0 = r1.copy(r0)
            boolean r1 = r0.success()
            if (r1 == 0) goto L_0x0054
            java.lang.String r1 = r0.job_token()
            r4.jobToken = r1
            goto L_0x0054
        L_0x0024:
            epson.print.copy.Component.eremoteoperation.ERemoteCopy r0 = r4.operation
            epson.print.copy.Component.ecopycomponent.RemoteCopyTask$7 r1 = new epson.print.copy.Component.ecopycomponent.RemoteCopyTask$7
            r1.<init>()
            epson.print.copy.Component.eremoteoperation.ERemoteCopy$ERemoteCopyStatusResult r0 = r0.getStatus(r1)
            boolean r1 = r0.success()
            if (r1 == 0) goto L_0x0054
            java.util.ArrayList r1 = r0.job_tokens()
            java.util.Iterator r1 = r1.iterator()
        L_0x003d:
            boolean r2 = r1.hasNext()
            if (r2 == 0) goto L_0x0054
            java.lang.Object r2 = r1.next()
            java.lang.String r2 = (java.lang.String) r2
            java.lang.String r3 = r4.recoverJobToken
            boolean r3 = r2.equals(r3)
            if (r3 == 0) goto L_0x003d
            r4.jobToken = r2
            goto L_0x003d
        L_0x0054:
            return r0
        */
        throw new UnsupportedOperationException("Method not decompiled: epson.print.copy.Component.ecopycomponent.RemoteCopyTask.startCopy():epson.print.copy.Component.eremoteoperation.ERemoteOperation$ERemoteReasonResult");
    }

    private CopyParams getCopyParams(@NonNull ERemoteCopy.IRemoteCopyParameter iRemoteCopyParameter) {
        String str;
        try {
            CopyParams copyParams = new CopyParams();
            copyParams.colorMode = iRemoteCopyParameter.color_effects_type().toString();
            copyParams.density = Integer.toString(iRemoteCopyParameter.x_density());
            int copy_magnification = iRemoteCopyParameter.copy_magnification();
            if (copy_magnification == 0) {
                str = "-999";
            } else {
                str = Integer.toString(copy_magnification);
            }
            copyParams.magnification = str;
            copyParams.paperSize = iRemoteCopyParameter.print_media_size().toString();
            copyParams.paperType = iRemoteCopyParameter.print_media_type().toString();
            copyParams.printDevice = iRemoteCopyParameter.print_media_source().toString();
            copyParams.copyType = iRemoteCopyParameter.scan_content_type().toString();
            copyParams.copyQuality = iRemoteCopyParameter.print_quality().toString();
            return copyParams;
        } catch (Throwable unused) {
            return null;
        }
    }

    protected Result doInBackground(Void... voidArr) {
        this.operation.setHostIP(this.systemSettings.getPrinterIPAddress());
        ERemoteOperation.ERemoteReasonResult startCopy = startCopy();
        if (!startCopy.success()) {
            return new Result(startCopy);
        }
        Result result = null;
        boolean z = false;
        boolean z2 = false;
        while (!z) {
            if (this.cancelRequested && !z2) {
                if (!this.operation.cancel(this.cancelParameter).success()) {
                    return new Result(ERemoteOperation.ERemoteParam.canceled);
                }
                z2 = true;
            }
            final ERemoteCopy.ERemoteCopyStatusResult status = this.operation.getStatus(this.statusParameter);
            if (!status.success()) {
                sendLog(this.progress.currentPages);
                return new Result((ERemoteOperation.ERemoteReasonResult) status);
            }
            Result result2 = new Result(status.job_result());
            this.progress.totalPages = status.job_print_total_pages();
            this.progress.currentPages = status.job_print_current_pages();
            if (this.progress.currentPages < 1) {
                this.progress.currentPages = 1;
            }
            ERemoteOperation.ERemoteParam job_state = status.job_state();
            switch (job_state) {
                case scanning:
                    this.progress.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Scanning;
                    break;
                case copying:
                    this.progress.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Copying;
                    break;
                case canceling:
                    this.progress.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Canceling;
                    break;
                case nextpaper:
                    Progress progress2 = this.progress;
                    progress2.resumeState = null;
                    progress2.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Waiting2ndPage;
                    this.progress.resumeRequest = new ECopyComponent.ICopyInvalidateResumeRequest() {
                        public void invalidate() {
                        }

                        public boolean isPossibleClearError() {
                            return false;
                        }

                        public ECopyComponent.ICopyResumeRequest.StopReason getStopReason() {
                            return ECopyComponent.ICopyResumeRequest.StopReason.ChangePage;
                        }

                        public void resume(ECopyComponent.ICopyResumeRequest.ResumeState resumeState) {
                            RemoteCopyTask.this.resumeNotify(resumeState);
                        }
                    };
                    break;
                case finished:
                    sendLog(this.progress.currentPages);
                    result = result2;
                    z = true;
                    continue;
            }
            switch (status.printer_state()) {
                case stopped:
                    if (job_state == ERemoteOperation.ERemoteParam.copying || job_state == ERemoteOperation.ERemoteParam.scanning) {
                        Progress progress3 = this.progress;
                        progress3.resumeState = null;
                        progress3.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Stopped;
                        this.progress.resumeRequest = new ECopyComponent.ICopyInvalidateResumeRequest() {
                            public void invalidate() {
                            }

                            public ECopyComponent.ICopyResumeRequest.StopReason getStopReason() {
                                ECopyComponent.ICopyResumeRequest.StopReason printerStopReason = RemoteCopyTask.getPrinterStopReason(status.printer_state_reasons());
                                return printerStopReason == ECopyComponent.ICopyResumeRequest.StopReason.None ? RemoteCopyTask.getScannerStopReason(status.scanner_state_reasons()) : printerStopReason;
                            }

                            public boolean isPossibleClearError() {
                                switch (RemoteCopyTask.getPrinterStopReason(status.printer_state_reasons())) {
                                    case PrinterMarkerSupplyEmptyError:
                                        return false;
                                    case PrinterMarkerWasteFullError:
                                        return false;
                                    case PrinterMediaJamError:
                                        return true;
                                    case PrinterMediaEmptyError:
                                        return true;
                                    case PrinterInputTrayMissingError:
                                        return true;
                                    case PrinterCoverOpenError:
                                        return false;
                                    case PrinterOutputAreaFullError:
                                        return true;
                                    case PrinterOtherError:
                                        return false;
                                    default:
                                        switch (RemoteCopyTask.getScannerStopReason(status.scanner_state_reasons())) {
                                            case ScannerMediaEmptyError:
                                                return true;
                                            case ScannerMediaJamError:
                                                return true;
                                            case ScannerMediaSizeMissmatchError:
                                                return true;
                                            case ScannerOtherError:
                                                return true;
                                            default:
                                                return false;
                                        }
                                }
                            }

                            public void resume(ECopyComponent.ICopyResumeRequest.ResumeState resumeState) {
                                RemoteCopyTask.this.progress.taskProgress = ECopyComponent.ICopyStatusListener.CopyTaskProgress.Processing;
                                RemoteCopyTask remoteCopyTask = RemoteCopyTask.this;
                                remoteCopyTask.publishProgress(new Progress[]{remoteCopyTask.progress});
                                RemoteCopyTask.this.resumeNotify(resumeState);
                            }
                        };
                        break;
                    }
            }
            publishProgress(new Progress[]{this.progress});
            resumeExecute();
            try {
                Thread.sleep((long) 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            result = result2;
        }
        return result;
    }

    private void sendLog(int i) {
        CopyParams copyParams = this.mCopyParams;
        Context context = this.mContext;
        if (context != null && copyParams != null) {
            CommonLog commonLog = new CommonLog();
            commonLog.setConnectionType(context);
            commonLog.setPrinterName(context);
            commonLog.action = PrintLog.ACTION_COPY;
            commonLog.numberOfSheet = i;
            Analytics.sendCopyLog(context, copyParams, commonLog);
        }
    }

    protected void onPostExecute(Result result) {
        this.statusListener.onFinished(ECopyComponent.ICopyStatusListener.CopyTaskType.Copy, result.taskResult);
    }
}