IPrint/app/src/main/java/epson/print/copy/CopyActivity.java

package epson.print.copy;

import android.content.Intent;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.CompoundButton;
import android.widget.ImageView;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;
import com.epson.mobilephone.common.maintain2.MaintainPrinter2;
import com.epson.mobilephone.common.wifidirect.WiFiDirectManager;
import epson.common.Utils;
import epson.print.R;
import epson.print.MyPrinter;
import epson.print.Util.EPLog;
import epson.print.copy.ActivityBase;
import epson.print.copy.Component.ecopycomponent.ECopyComponent;
import epson.print.copy.Component.ecopycomponent.ECopyOptionContext;
import epson.print.copy.Component.ecopycomponent.ECopyOptionItem;
import epson.print.copy.Component.eremoteoperation.ERemoteDevice;
import epson.print.copy.Component.eremoteoperation.ERemoteOperation;
import epson.print.widgets.LongTapRepeatAdapter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Locale;

public class CopyActivity extends ActivityBase implements View.OnClickListener {
    private static final int CONNECTION_TIMEOUT = 30000;
    private static final int EPS_COMM_BID = 2;
    private static final int REQUEST_CODE_REPEAT_COPY = 12;
    private final int COMM_ERROR = 1;
    private final int PROBE_PRINTER = 0;
    /* access modifiers changed from: private */
    public String TAG = "CopyActivty";
    private final int UPDATE_SETTING = 2;
    boolean bProbedPrinter = false;
    /* access modifiers changed from: private */
    public int clearindex = 0;
    CopyProcess copyProcess;
    /* access modifiers changed from: private */
    public boolean doClear = false;
    /* access modifiers changed from: private */
    public ActivityBase.errorDialog errordialog;
    /* access modifiers changed from: private */
    public String ipAdress;
    private RadioGroup mCopyTypeGroup;
    Handler mHandler = new Handler(new Handler.Callback() {
        public boolean handleMessage(Message message) {
            EPLog.m313i(CopyActivity.this.TAG, "HandlerCallback");
            switch (message.what) {
                case 0:
                    EPLog.m313i(CopyActivity.this.TAG, "PROBE_PRINTER");
                    CopyActivity copyActivity = CopyActivity.this;
                    ProbePrinter unused = copyActivity.task = new ProbePrinter();
                    CopyActivity.this.task.execute(new Void[0]);
                    return true;
                case 1:
                    EPLog.m313i(CopyActivity.this.TAG, "COMM_ERROR");
                    CopyActivity copyActivity2 = CopyActivity.this;
                    ActivityBase.errorDialog unused2 = copyActivity2.errordialog = new ActivityBase.errorDialog(copyActivity2);
                    CopyActivity.this.errordialog.showErrorDialog(CopyActivity.this.getString(R.string.EPS_PRNERR_COMM_TITLE), CopyActivity.this.getString(R.string.EPS_PRNERR_COMM5), ActivityBase.DialogButtons.Ok, new ActivityBase.IClose() {
                        public void onClose(ActivityBase.ClickButton clickButton) {
                            CopyActivity.this.finish();
                        }
                    });
                    return true;
                case 2:
                    EPLog.m313i(CopyActivity.this.TAG, "UPDATE_SETTING");
                    if (CopyActivity.this.optionContext == null) {
                        CopyActivity.this.fetchCopyOptionContext();
                        return true;
                    }
                    CopyActivity copyActivity3 = CopyActivity.this;
                    copyActivity3.optionContext = copyActivity3.copyComponent.getBindedCopyOptionContext();
                    CopyActivity.this.copyComponent.bindCopyOptionContext(CopyActivity.this.optionContext, CopyActivity.this.optionListener);
                    CopyActivity copyActivity4 = CopyActivity.this;
                    copyActivity4.buildCopyOptions(copyActivity4.copyComponent.getCopyOptionItems());
                    return true;
                default:
                    return true;
            }
        }
    });
    private ViewGroup mLayout;
    private RadioButton mNormalCopyButton;
    /* access modifiers changed from: private */
    public MaintainPrinter2 mPrinter;
    private RadioButton mRepeatCopyButton;
    ECopyComponent.ICopyOptionListener optionListener;
    ActivityBase.OptionItemChangedListener optionValueChangedListener;
    /* access modifiers changed from: private */
    public ActivityBase.settingPreference presettings = new ActivityBase.settingPreference();
    /* access modifiers changed from: private */
    public int printerLocation;
    ECopyComponent.ICopySystemSettings systemSettings;
    /* access modifiers changed from: private */
    public ProbePrinter task;

    public void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        this.copyComponent.getRemoteOperationUUID(this);
        this.optionContext = null;
        this.mLayout = (ViewGroup) getLayoutInflater().inflate(R.layout.copy, (ViewGroup) null);
        setContentView((View) this.mLayout);
        setupUi();
        setActionBar((int) R.string.FunctionName_iPrint_Copy, true);
        if (this.mPrinter == null) {
            this.mPrinter = MaintainPrinter2.getInstance();
        }
        this.optionValueChangedListener = new ActivityBase.OptionItemChangedListener() {
            public void onOptionItemChanged(ECopyOptionItem eCopyOptionItem) {
                CopyActivity.this.copyComponent.setCopyOptionItem(eCopyOptionItem);
            }
        };
        this.optionListener = new ECopyComponent.ICopyOptionListener() {
            public void onCopyOptionChanged(ECopyOptionItem eCopyOptionItem, ArrayList<ECopyOptionItem> arrayList, ECopyComponent.ICopyOptionListener.CopyOptionChangedError copyOptionChangedError) {
                if (copyOptionChangedError != null) {
                    CopyActivity.this.loading.dismiss();
                    CopyActivity copyActivity = CopyActivity.this;
                    ActivityBase.errorDialog errordialog = new ActivityBase.errorDialog(copyActivity);
                    String[] reasonText = errordialog.getReasonText(copyOptionChangedError);
                    errordialog.showErrorDialog(reasonText[0], reasonText[1]);
                    return;
                }
                ArrayList arrayList2 = new ArrayList();
                if (CopyActivity.this.doClear) {
                    if (CopyActivity.this.clearindex != CopyActivity.this.copyComponent.getCopyOptionItems().size()) {
                        CopyActivity.this.allClear();
                        return;
                    }
                    boolean unused = CopyActivity.this.doClear = false;
                    int unused2 = CopyActivity.this.clearindex = 0;
                    arrayList2.addAll(CopyActivity.this.copyComponent.getCopyOptionItems());
                }
                arrayList2.add(eCopyOptionItem);
                if (arrayList != null) {
                    arrayList2.addAll(arrayList);
                }
                CopyActivity.this.buildCopyOptions(arrayList2);
            }
        };
    }

    public void onResume() {
        EPLog.m316v(this.TAG, "onResume()");
        super.onResume();
        this.isKeepSimpleAPConnection = false;
        getPrinterInfo();
        CopyProcess copyProcess2 = this.copyProcess;
        if (copyProcess2 == null || !copyProcess2.isProccessing()) {
            if (!WiFiDirectManager.isNeedConnect(this, WiFiDirectManager.DEVICE_TYPE_PRINTER)) {
                this.isTryConnectSimpleAp = false;
            } else if (!this.isTryConnectSimpleAp) {
                this.isTryConnectSimpleAp = true;
                if (WiFiDirectManager.reconnect(this, WiFiDirectManager.DEVICE_TYPE_PRINTER, -1)) {
                    this.isKeepSimpleAPConnection = true;
                    this.bProbedPrinter = false;
                    return;
                }
            }
            this.loading.show();
            if (!this.bProbedPrinter) {
                this.mHandler.sendEmptyMessage(0);
            } else {
                this.mHandler.sendEmptyMessage(2);
            }
        } else {
            this.copyProcess.setDisconnectWifi(false);
        }
    }

    public void onPause() {
        EPLog.m316v(this.TAG, "onPause()");
        super.onPause();
        int i = this.printerLocation;
        if (i == 1 || i == 3) {
            ProbePrinter probePrinter = this.task;
            if (probePrinter != null) {
                probePrinter.cancel(true);
            }
            CopyProcess copyProcess2 = this.copyProcess;
            if (copyProcess2 != null && copyProcess2.isProccessing()) {
                this.copyProcess.setDisconnectWifi(true);
            } else if (!this.isKeepSimpleAPConnection) {
                WiFiDirectManager.disconnect(this, WiFiDirectManager.DEVICE_TYPE_PRINTER, ActivityBase.printerIp);
            }
        }
        if (isFinishing()) {
            deleteLongTapMessage();
        }
    }

    /* access modifiers changed from: protected */
    public void onDestroy() {
        super.onDestroy();
    }

    /* access modifiers changed from: protected */
    public void onActivityResult(int i, int i2, Intent intent) {
        if (i == 12) {
            if (i2 == -1) {
                finish();
            } else {
                this.mNormalCopyButton.setChecked(true);
            }
        }
    }

    private void setupUi() {
        findViewById(R.id.color).setOnClickListener(this);
        findViewById(R.id.scale).setOnClickListener(this);
        findViewById(R.id.paper_size).setOnClickListener(this);
        findViewById(R.id.paper_type).setOnClickListener(this);
        findViewById(R.id.paper_source).setOnClickListener(this);
        findViewById(R.id.document_type).setOnClickListener(this);
        findViewById(R.id.quality).setOnClickListener(this);
        findViewById(R.id.copy_setting_clear_all).setOnClickListener(this);
        findViewById(R.id.copy_button).setOnClickListener(this);
        LongTapRepeatAdapter.bless(findViewById(R.id.SettingButonCopiesCountUp));
        LongTapRepeatAdapter.bless(findViewById(R.id.SettingButonCopiesCountDown));
        LongTapRepeatAdapter.bless(findViewById(R.id.SettingButonXDensityCountUp));
        LongTapRepeatAdapter.bless(findViewById(R.id.SettingButonXDensityCountDown));
        this.mCopyTypeGroup = (RadioGroup) findViewById(R.id.copy_type_group);
        this.mNormalCopyButton = (RadioButton) findViewById(R.id.normal_copy_tab);
        this.mNormalCopyButton.setChecked(true);
        this.mNormalCopyButton.setEnabled(false);
        this.mNormalCopyButton.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            public void onCheckedChanged(CompoundButton compoundButton, boolean z) {
            }
        });
        this.mRepeatCopyButton = (RadioButton) findViewById(R.id.repeat_copy_tab);
        this.mRepeatCopyButton.setChecked(false);
        this.mNormalCopyButton.setEnabled(false);
        this.mRepeatCopyButton.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            public void onCheckedChanged(CompoundButton compoundButton, boolean z) {
                if (z) {
                    CopyActivity.this.switchToRepeatCopy();
                }
            }
        });
    }

    /* access modifiers changed from: private */
    public void switchToRepeatCopy() {
        this.isKeepSimpleAPConnection = true;
        startActivityForResult(new Intent(this, epson.print.rpcopy.CopyActivity.class), 12);
    }

    public void onClick(View view) {
        Intent intent = new Intent();
        switch (view.getId()) {
            case R.id.color /*2131230930*/:
                intent.setClass(getBaseContext(), CopySettingActivity.class);
                intent.putExtra("Key", ECopyOptionItem.ECopyOptionItemKey.ColorEffectsType.name());
                startActivityAndKeepSimpleAp(intent);
                return;
            case R.id.copy_button /*2131230948*/:
                String str = this.TAG;
                EPLog.m313i(str, "NOW_PRINTER:" + printerId);
                this.presettings.saveCopyOptions(this.copyComponent.getCopyOptionItems());
                this.copyProcess = new CopyProcess(this);
                this.copyProcess.startCopy(getApplicationContext());
                return;
            case R.id.copy_setting_clear_all /*2131230967*/:
                allClear();
                return;
            case R.id.document_type /*2131231000*/:
                intent.setClass(getBaseContext(), CopySettingActivity.class);
                intent.putExtra("Key", ECopyOptionItem.ECopyOptionItemKey.ScanContentType.name());
                startActivityAndKeepSimpleAp(intent);
                return;
            case R.id.paper_size /*2131231306*/:
                intent.setClass(getBaseContext(), CopySettingActivity.class);
                intent.putExtra("Key", ECopyOptionItem.ECopyOptionItemKey.PrintMediaSize.name());
                startActivityAndKeepSimpleAp(intent);
                return;
            case R.id.paper_source /*2131231311*/:
                intent.setClass(getBaseContext(), CopySettingActivity.class);
                intent.putExtra("Key", ECopyOptionItem.ECopyOptionItemKey.PrintMediaSource.name());
                startActivityAndKeepSimpleAp(intent);
                return;
            case R.id.paper_type /*2131231314*/:
                intent.setClass(getBaseContext(), CopySettingActivity.class);
                intent.putExtra("Key", ECopyOptionItem.ECopyOptionItemKey.PrintMediaType.name());
                startActivityAndKeepSimpleAp(intent);
                return;
            case R.id.quality /*2131231392*/:
                intent.setClass(getBaseContext(), CopySettingActivity.class);
                intent.putExtra("Key", ECopyOptionItem.ECopyOptionItemKey.PrintQuality.name());
                startActivityAndKeepSimpleAp(intent);
                return;
            case R.id.scale /*2131231441*/:
                intent.setClass(getBaseContext(), CopyScaleActivity.class);
                intent.putExtra("Key", ECopyOptionItem.ECopyOptionItemKey.XScale.name());
                startActivityAndKeepSimpleAp(intent);
                return;
            default:
                return;
        }
    }

    /* access modifiers changed from: package-private */
    public void startActivityAndKeepSimpleAp(Intent intent) {
        this.isKeepSimpleAPConnection = true;
        startActivity(intent);
    }

    /* access modifiers changed from: package-private */
    public void allClear() {
        this.doClear = true;
        this.loading.show();
        ArrayList<ECopyOptionItem> copyOptionItems = this.copyComponent.getCopyOptionItems();
        int i = this.clearindex;
        this.clearindex = i + 1;
        ECopyOptionItem eCopyOptionItem = copyOptionItems.get(i);
        switch (eCopyOptionItem.getKey()) {
            case ColorEffectsType:
                eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.ColorEffectsType_Color);
                break;
            case ScanContentType:
                eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.ScanContentType_Mixed);
                break;
            case PrintMediaType:
                eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.PrintMediaType_Stationery);
                break;
            case PrintMediaSize:
                if (Locale.getDefault().getLanguage().equalsIgnoreCase(Locale.US.getLanguage()) && eCopyOptionItem.getSelectableChoices().contains(ECopyOptionItem.ECopyOptionItemChoice.PrintMediaSize_Letter)) {
                    eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.PrintMediaSize_Letter);
                    break;
                } else {
                    eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.PrintMediaSize_A4);
                    break;
                }
                break;
            case PrintMediaSource:
                eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.PrintMediaSource_Bottom);
                break;
            case PrintQuality:
                eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.PrintQuality_Normal);
                break;
            case XScale:
                eCopyOptionItem.selectChoice(ECopyOptionItem.ECopyOptionItemChoice.XScale_Autofit);
                break;
            case XDensity:
            case CopyMagnification:
            case Copies:
                eCopyOptionItem.selectValue(eCopyOptionItem.getDefaultValue());
                break;
        }
        this.copyComponent.setCopyOptionItem(eCopyOptionItem);
    }

    /* access modifiers changed from: package-private */
    public void fetchCopyOptionContext() {
        this.copyComponent.createCopyOptionContext(this.copyType, new ECopyComponent.ICopyOptionContextListener() {
            public void onCopyOptionContextCreated(ECopyComponent.ECopyType eCopyType, ECopyOptionContext eCopyOptionContext, ECopyComponent.ICopyOptionContextListener.ContextCreationError contextCreationError) {
                CopyActivity copyActivity = CopyActivity.this;
                copyActivity.optionContext = eCopyOptionContext;
                if (contextCreationError == null) {
                    copyActivity.copyComponent.bindCopyOptionContext(CopyActivity.this.optionContext, CopyActivity.this.optionListener);
                    ArrayList<ECopyOptionItem> copyOptionItems = CopyActivity.this.copyComponent.getCopyOptionItems();
                    if (ActivityBase.printerId.equalsIgnoreCase(CopyActivity.this.presettings.loadPrePrinter())) {
                        CopyActivity.this.presettings.setCopyOptions(copyOptionItems);
                    } else {
                        CopyActivity.this.buildCopyOptions(copyOptionItems);
                    }
                } else {
                    ActivityBase.errorDialog unused = copyActivity.errordialog = new ActivityBase.errorDialog(copyActivity);
                    String[] reasonText = CopyActivity.this.errordialog.getReasonText(contextCreationError);
                    CopyActivity.this.errordialog.showErrorDialog(reasonText[0], reasonText[1], ActivityBase.DialogButtons.Ok, new ActivityBase.IClose() {
                        public void onClose(ActivityBase.ClickButton clickButton) {
                            CopyActivity.this.finish();
                        }
                    });
                }
            }
        });
    }

    /* access modifiers changed from: package-private */
    public void buildCopyOptions(ArrayList<ECopyOptionItem> arrayList) {
        Iterator<ECopyOptionItem> it = arrayList.iterator();
        while (it.hasNext()) {
            ECopyOptionItem next = it.next();
            ECopyOptionItem.ECopyOptionItemKey key = next.getKey();
            switch (key) {
                case ColorEffectsType:
                    String str = this.TAG;
                    EPLog.m313i(str, "show " + key.name() + ":" + next.getSelectedChoice() + " setting");
                    updateSetting(R.id.copy_color_info, next);
                    break;
                case ScanContentType:
                    String str2 = this.TAG;
                    EPLog.m313i(str2, "show " + key.name() + ":" + next.getSelectedChoice() + " setting");
                    updateSetting(R.id.copy_document_type_info, next);
                    break;
                case PrintMediaType:
                    String str3 = this.TAG;
                    EPLog.m313i(str3, "show " + key.name() + ":" + next.getSelectedChoice() + " setting");
                    updateSetting(R.id.copy_paper_type_info, next);
                    break;
                case PrintMediaSize:
                    String str4 = this.TAG;
                    EPLog.m313i(str4, "show " + key.name() + ":" + next.getSelectedChoice() + " setting");
                    updateSetting(R.id.copy_paper_size_info, next);
                    break;
                case PrintMediaSource:
                    String str5 = this.TAG;
                    EPLog.m313i(str5, "show " + key.name() + ":" + next.getSelectedChoice() + " setting");
                    updateSetting(R.id.copy_paper_source_info, next);
                    break;
                case PrintQuality:
                    String str6 = this.TAG;
                    EPLog.m313i(str6, "show " + key.name() + ":" + next.getSelectedChoice() + " setting");
                    updateSetting(R.id.copy_quality_info, next);
                    break;
                case XScale:
                    String str7 = this.TAG;
                    EPLog.m313i(str7, "show " + key.name() + ":" + next.getSelectedChoice() + " setting");
                    updateSetting(R.id.copy_scale_info, next);
                    break;
                case XDensity:
                    this.optionValueMap.put(key, new XDensityValue(next));
                    break;
                case CopyMagnification:
                    this.optionValueMap.put(key, new ActivityBase.CopyMagnificationValue(next));
                    break;
                case Copies:
                    this.optionValueMap.put(key, new CopiesValue(next));
                    break;
            }
            this.loading.dismiss();
        }
    }

    /* access modifiers changed from: package-private */
    public void updateSetting(int i, ECopyOptionItem eCopyOptionItem) {
        TextView textView = (TextView) this.mLayout.findViewById(i);
        if (eCopyOptionItem.getSelectedChoice() == ECopyOptionItem.ECopyOptionItemChoice.XScale_Custom) {
            textView.setText(getString(R.string.XScale_CustomSetting) + String.valueOf(((ActivityBase.NumberOptionValue) this.optionValueMap.get(ECopyOptionItem.ECopyOptionItemKey.CopyMagnification)).value) + " %");
            return;
        }
        textView.setText(string(eCopyOptionItem.getSelectedChoice().name()));
    }

    class CopiesValue extends ActivityBase.NumberOptionValue {
        public CopiesValue(ECopyOptionItem eCopyOptionItem) {
            super();
            bindOption(R.id.SettingEditCopies, eCopyOptionItem);
            bindCountUp(R.id.SettingButonCopiesCountUp);
            bindCountDown(R.id.SettingButonCopiesCountDown);
            setOptionValueChangedListener(CopyActivity.this.optionValueChangedListener);
        }
    }

    class XDensityValue extends ActivityBase.NumberOptionValue {
        ImageView image;
        TypedArray images = CopyActivity.this.getResources().obtainTypedArray(R.array.density_images);

        public XDensityValue(ECopyOptionItem eCopyOptionItem) {
            super();
            bindOption(R.id.density_image, eCopyOptionItem);
            bindCountUp(R.id.SettingButonXDensityCountUp);
            bindCountDown(R.id.SettingButonXDensityCountDown);
            setOptionValueChangedListener(CopyActivity.this.optionValueChangedListener);
        }

        /* access modifiers changed from: package-private */
        public void bindOption(int i, ECopyOptionItem eCopyOptionItem) {
            this.optionItem = eCopyOptionItem;
            this.value = eCopyOptionItem.getSelectedValue();
            this.image = (ImageView) CopyActivity.this.findViewById(i);
            this.image.setImageDrawable(this.images.getDrawable(this.value + 4));
            this.image.setEnabled(eCopyOptionItem.isEnabled());
        }

        /* access modifiers changed from: package-private */
        public void bindCountUp(int i) {
            this.countUp = (Button) CopyActivity.this.findViewById(i);
            this.countUp.setOnClickListener(new CounterImage(1));
            if (this.value == this.optionItem.getMaximumValue()) {
                this.countUp.setEnabled(false);
            } else {
                this.countUp.setEnabled(true);
            }
        }

        /* access modifiers changed from: package-private */
        public void bindCountDown(int i) {
            this.countDown = (Button) CopyActivity.this.findViewById(i);
            this.countDown.setOnClickListener(new CounterImage(-1));
            if (this.value == this.optionItem.getMinimumValue()) {
                this.countDown.setEnabled(false);
            } else {
                this.countDown.setEnabled(true);
            }
        }

        class CounterImage extends ActivityBase.NumberOptionValue.Counter implements View.OnClickListener {
            public CounterImage(int i) {
                super(i);
            }

            /* access modifiers changed from: package-private */
            public void updateImage(int i) {
                XDensityValue.this.value += i;
                XDensityValue.this.optionItem.selectValue(XDensityValue.this.value);
                if (XDensityValue.this.changedListener != null) {
                    XDensityValue.this.changedListener.onOptionItemChanged(XDensityValue.this.optionItem);
                }
            }

            public void onClick(View view) {
                updateImage(this.amount);
            }
        }
    }

    private void getPrinterInfo() {
        MyPrinter curPrinter = MyPrinter.getCurPrinter(this);
        printerId = curPrinter.getPrinterId();
        printerIp = curPrinter.getIp();
        this.printerLocation = curPrinter.getLocation();
    }

    private class ProbePrinter extends AsyncTask<Void, Void, Boolean> {
        private volatile boolean mRepeatCopyAvailable;

        /* access modifiers changed from: protected */
        public void onPreExecute() {
        }

        private ProbePrinter() {
        }

        /* access modifiers changed from: protected */
        public Boolean doInBackground(Void... voidArr) {
            EPLog.m313i(CopyActivity.this.TAG, "ProbePrinter doInBackground");
            this.mRepeatCopyAvailable = false;
            if ((CopyActivity.this.printerLocation != 1 && CopyActivity.this.printerLocation != 3) || ActivityBase.printerId == null) {
                return false;
            }
            CopyActivity.this.mPrinter.doInitDriver(CopyActivity.this, 2);
            if (CopyActivity.this.mPrinter.doProbePrinter(60, ActivityBase.printerId, ActivityBase.printerIp, CopyActivity.this.printerLocation) != 0) {
                return false;
            }
            int doSetPrinter = CopyActivity.this.mPrinter.doSetPrinter();
            String access$200 = CopyActivity.this.TAG;
            EPLog.m313i(access$200, "Set Printer result: " + doSetPrinter);
            if (doSetPrinter != 0) {
                return false;
            }
            CopyActivity copyActivity = CopyActivity.this;
            String unused = copyActivity.ipAdress = copyActivity.mPrinter.doGetIp();
            String access$2002 = CopyActivity.this.TAG;
            EPLog.m313i(access$2002, "IPAdress : " + CopyActivity.this.ipAdress);
            CopyActivity copyActivity2 = CopyActivity.this;
            copyActivity2.bProbedPrinter = true;
            copyActivity2.systemSettings = new ECopyComponent.ICopySystemSettings() {
                public int getThickPaper() {
                    return 0;
                }

                public String getPrinterIPAddress() {
                    String access$200 = CopyActivity.this.TAG;
                    EPLog.m313i(access$200, "getPrinterIPAddress : " + CopyActivity.this.ipAdress);
                    return CopyActivity.this.ipAdress;
                }
            };
            ECopyComponent sharedComponent = ECopyComponent.sharedComponent();
            sharedComponent.setSystemSettings(CopyActivity.this.systemSettings);
            sharedComponent.setProperty(ECopyComponent.Property.RequestConnectionTimeout, CopyActivity.CONNECTION_TIMEOUT);
            this.mRepeatCopyAvailable = CopyActivity.this.checkRepeatCopyFunction();
            return true;
        }

        /* access modifiers changed from: protected */
        public void onCancelled() {
            EPLog.m313i(CopyActivity.this.TAG, "ProbePrinter onCancelled");
            super.onCancelled();
            CopyActivity.this.mPrinter.doCancelFindPrinter();
        }

        /* access modifiers changed from: protected */
        public void onPostExecute(Boolean bool) {
            EPLog.m313i(CopyActivity.this.TAG, "ProbePrinter onPostExecute");
            CopyActivity.this.changeRepeatCopyButtonState(this.mRepeatCopyAvailable);
            if (bool.booleanValue()) {
                CopyActivity.this.mHandler.sendEmptyMessage(2);
            } else {
                CopyActivity.this.mHandler.sendEmptyMessage(1);
            }
        }
    }

    /* access modifiers changed from: private */
    public boolean checkRepeatCopyFunction() {
        ERemoteDevice eRemoteDevice = new ERemoteDevice();
        eRemoteDevice.setHostIP(this.ipAdress);
        eRemoteDevice.setRequestConnectionTimeout(CONNECTION_TIMEOUT);
        ERemoteDevice.ERemoteDeviceFunctionsResult executeGetFunctionsCommand = eRemoteDevice.executeGetFunctionsCommand(Utils.getRemoteOperationUUID(getApplicationContext()));
        return executeGetFunctionsCommand.success() && executeGetFunctionsCommand.functions().contains(ERemoteOperation.ERemoteParam.repeat_copy);
    }

    /* access modifiers changed from: private */
    public void changeRepeatCopyButtonState(boolean z) {
        int i;
        boolean z2 = false;
        if (z) {
            i = 0;
            z2 = true;
        } else {
            i = 8;
        }
        this.mCopyTypeGroup.setVisibility(i);
        this.mRepeatCopyButton.setEnabled(z2);
    }

    /* access modifiers changed from: protected */
    public void deleteLongTapMessage() {
        MotionEvent obtain = MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis() + 10, 1, 0.0f, 0.0f, 0);
        findViewById(R.id.SettingButonCopiesCountUp).dispatchTouchEvent(obtain);
        findViewById(R.id.SettingButonCopiesCountDown).dispatchTouchEvent(obtain);
        findViewById(R.id.SettingButonXDensityCountUp).dispatchTouchEvent(obtain);
        findViewById(R.id.SettingButonXDensityCountDown).dispatchTouchEvent(obtain);
    }

    public void onConfigurationChanged(Configuration configuration) {
        super.onConfigurationChanged(configuration);
        deleteLongTapMessage();
    }
}