Kaspi.kz v5.85.1 - setClassifierNamePolicy.java 源代码

package o;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import com.google.zxing.ResultMetadataType;
import com.google.zxing.ResultPoint;
import com.google.zxing.client.android.BeepManager;
import com.google.zxing.client.android.InactivityTimer;
import com.google.zxing.client.android.Intents;
import com.google.zxing.client.android.R;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import o.renderTypeConstructor;
import o.setClassifierNamePolicy;

public class setClassifierNamePolicy {
    private static final String setBackground = "SAVED_ORIENTATION_LOCK";
    private static int setLabel = 250;
    private static final String setOptions = "CaptureManager";
    private InactivityTimer AudioAttributesImplApi21Parcelizer;
    private Handler AudioAttributesImplApi26Parcelizer;
    private final renderTypeConstructor.setLabel MediaBrowserCompatItemReceiver;
    private DescriptorRendererImplLambda0 RemoteActionCompatParcelizer;
    private BeepManager read;
    private Activity setError;
    private boolean setFieldValue;
    private int MediaBrowserCompatCustomActionResultReceiver = -1;
    private boolean AudioAttributesCompatParcelizer = false;
    private boolean MediaBrowserCompatSearchResultReceiver = true;
    private String AudioAttributesImplBaseParcelizer = "";
    private boolean IconCompatParcelizer = false;
    private boolean setElement = false;
    private getWithDefinedIn write = new AnonymousClass1();

    class AnonymousClass1 implements getWithDefinedIn {
        @Override
        public void setBackground(List<ResultPoint> list) {
        }

        AnonymousClass1() {
        }

        @Override
        public void setOptions(final renderTypeArguments rendertypearguments) {
            setClassifierNamePolicy.this.RemoteActionCompatParcelizer.write();
            setClassifierNamePolicy.this.read.playBeepSoundAndVibrate();
            setClassifierNamePolicy.this.AudioAttributesImplApi26Parcelizer.post(new Runnable() {
                @Override
                public final void run() {
                    setClassifierNamePolicy.AnonymousClass1.this.setError(rendertypearguments);
                }
            });
        }

        public void setError(renderTypeArguments rendertypearguments) {
            setClassifierNamePolicy.this.setFieldValue(rendertypearguments);
        }
    }

    public setClassifierNamePolicy(Activity activity, DescriptorRendererImplLambda0 descriptorRendererImplLambda0) {
        renderTypeConstructor.setLabel setlabel = new renderTypeConstructor.setLabel() {
            @Override
            public void setBackground() {
            }

            @Override
            public void setFieldValue() {
            }

            @Override
            public void setOptions() {
            }

            @Override
            public void setError(Exception exc) {
                setClassifierNamePolicy setclassifiernamepolicy = setClassifierNamePolicy.this;
                setclassifiernamepolicy.setFieldValue(setclassifiernamepolicy.setError.getString(R.string.zxing_msg_camera_framework_bug));
            }

            @Override
            public void setError() {
                if (setClassifierNamePolicy.this.setElement) {
                    Log.d(setClassifierNamePolicy.setOptions, "Camera closed; finishing activity");
                    setClassifierNamePolicy.this.read();
                }
            }
        };
        this.MediaBrowserCompatItemReceiver = setlabel;
        this.setFieldValue = false;
        this.setError = activity;
        this.RemoteActionCompatParcelizer = descriptorRendererImplLambda0;
        descriptorRendererImplLambda0.setOptions().setOptions(setlabel);
        this.AudioAttributesImplApi26Parcelizer = new Handler();
        this.AudioAttributesImplApi21Parcelizer = new InactivityTimer(activity, new Runnable() {
            @Override
            public final void run() {
                setClassifierNamePolicy.this.AudioAttributesCompatParcelizer();
            }
        });
        this.read = new BeepManager(activity);
    }

    public void AudioAttributesCompatParcelizer() {
        Log.d(setOptions, "Finishing due to inactivity");
        read();
    }

    public void setOptions(Intent intent, Bundle bundle) {
        this.setError.getWindow().addFlags(128);
        if (bundle != null) {
            this.MediaBrowserCompatCustomActionResultReceiver = bundle.getInt(setBackground, -1);
        }
        if (intent != null) {
            if (intent.getBooleanExtra(Intents.Scan.ORIENTATION_LOCKED, true)) {
                setBackground();
            }
            if (Intents.Scan.ACTION.equals(intent.getAction())) {
                this.RemoteActionCompatParcelizer.setError(intent);
            }
            if (!intent.getBooleanExtra(Intents.Scan.BEEP_ENABLED, true)) {
                this.read.setBeepEnabled(false);
            }
            if (intent.hasExtra(Intents.Scan.SHOW_MISSING_CAMERA_PERMISSION_DIALOG)) {
                setLabel(intent.getBooleanExtra(Intents.Scan.SHOW_MISSING_CAMERA_PERMISSION_DIALOG, true), intent.getStringExtra(Intents.Scan.MISSING_CAMERA_PERMISSION_DIALOG_MESSAGE));
            }
            if (intent.hasExtra(Intents.Scan.TIMEOUT)) {
                this.AudioAttributesImplApi26Parcelizer.postDelayed(new Runnable() {
                    @Override
                    public final void run() {
                        setClassifierNamePolicy.this.write();
                    }
                }, intent.getLongExtra(Intents.Scan.TIMEOUT, 0L));
            }
            if (intent.getBooleanExtra(Intents.Scan.BARCODE_IMAGE_ENABLED, false)) {
                this.AudioAttributesCompatParcelizer = true;
            }
        }
    }

    protected void setBackground() {
        if (this.MediaBrowserCompatCustomActionResultReceiver == -1) {
            int rotation = this.setError.getWindowManager().getDefaultDisplay().getRotation();
            int i = this.setError.getResources().getConfiguration().orientation;
            int i2 = 1;
            if (i == 2) {
                if (rotation != 0 && rotation != 1) {
                    i2 = 8;
                    this.MediaBrowserCompatCustomActionResultReceiver = i2;
                }
                i2 = 0;
                this.MediaBrowserCompatCustomActionResultReceiver = i2;
            } else {
                if (i == 1) {
                    if (rotation != 0 && rotation != 3) {
                        i2 = 9;
                    }
                    this.MediaBrowserCompatCustomActionResultReceiver = i2;
                }
                i2 = 0;
                this.MediaBrowserCompatCustomActionResultReceiver = i2;
            }
        }
        this.setError.setRequestedOrientation(this.MediaBrowserCompatCustomActionResultReceiver);
    }

    public void setError() {
        this.RemoteActionCompatParcelizer.setOptions(this.write);
    }

    public void IconCompatParcelizer() {
        AudioAttributesImplApi26Parcelizer();
        this.AudioAttributesImplApi21Parcelizer.start();
    }

    private void AudioAttributesImplApi26Parcelizer() {
        if (setCode39UseCheckDigit.checkSelfPermission(this.setError, "android.permission.CAMERA") == 0) {
            this.RemoteActionCompatParcelizer.IconCompatParcelizer();
        } else {
            if (this.setFieldValue) {
                return;
            }
            NativeOnCompleteListener.setOptions(this.setError, new String[]{"android.permission.CAMERA"}, setLabel);
            this.setFieldValue = true;
        }
    }

    public void setError(int i, String[] strArr, int[] iArr) {
        if (i == setLabel) {
            if (iArr.length > 0 && iArr[0] == 0) {
                this.RemoteActionCompatParcelizer.IconCompatParcelizer();
                return;
            }
            MediaBrowserCompatCustomActionResultReceiver();
            if (this.MediaBrowserCompatSearchResultReceiver) {
                setFieldValue(this.AudioAttributesImplBaseParcelizer);
            } else {
                setOptions();
            }
        }
    }

    public void setElement() {
        this.AudioAttributesImplApi21Parcelizer.cancel();
        this.RemoteActionCompatParcelizer.setElement();
    }

    public void RemoteActionCompatParcelizer() {
        this.IconCompatParcelizer = true;
        this.AudioAttributesImplApi21Parcelizer.cancel();
        this.AudioAttributesImplApi26Parcelizer.removeCallbacksAndMessages(null);
    }

    public void setOptions(Bundle bundle) {
        bundle.putInt(setBackground, this.MediaBrowserCompatCustomActionResultReceiver);
    }

    public static Intent setOptions(renderTypeArguments rendertypearguments, String str) {
        Intent intent = new Intent(Intents.Scan.ACTION);
        intent.addFlags(524288);
        intent.putExtra(Intents.Scan.RESULT, rendertypearguments.toString());
        intent.putExtra(Intents.Scan.RESULT_FORMAT, rendertypearguments.setBackground().toString());
        byte[] error = rendertypearguments.setError();
        if (error != null && error.length > 0) {
            intent.putExtra(Intents.Scan.RESULT_BYTES, error);
        }
        Map<ResultMetadataType, Object> IconCompatParcelizer = rendertypearguments.IconCompatParcelizer();
        if (IconCompatParcelizer != null) {
            ResultMetadataType resultMetadataType = ResultMetadataType.UPC_EAN_EXTENSION;
            if (IconCompatParcelizer.containsKey(resultMetadataType)) {
                intent.putExtra(Intents.Scan.RESULT_UPC_EAN_EXTENSION, IconCompatParcelizer.get(resultMetadataType).toString());
            }
            Number number = (Number) IconCompatParcelizer.get(ResultMetadataType.ORIENTATION);
            if (number != null) {
                intent.putExtra(Intents.Scan.RESULT_ORIENTATION, number.intValue());
            }
            String str2 = (String) IconCompatParcelizer.get(ResultMetadataType.ERROR_CORRECTION_LEVEL);
            if (str2 != null) {
                intent.putExtra(Intents.Scan.RESULT_ERROR_CORRECTION_LEVEL, str2);
            }
            Iterable iterable = (Iterable) IconCompatParcelizer.get(ResultMetadataType.BYTE_SEGMENTS);
            if (iterable != null) {
                Iterator it = iterable.iterator();
                int i = 0;
                while (it.hasNext()) {
                    intent.putExtra(Intents.Scan.RESULT_BYTE_SEGMENTS_PREFIX + i, (byte[]) it.next());
                    i++;
                }
            }
        }
        if (str != null) {
            intent.putExtra(Intents.Scan.RESULT_BARCODE_IMAGE_PATH, str);
        }
        return intent;
    }

    private String setError(renderTypeArguments rendertypearguments) {
        if (this.AudioAttributesCompatParcelizer) {
            Bitmap fieldValue = rendertypearguments.setFieldValue();
            try {
                File createTempFile = File.createTempFile("barcodeimage", ".jpg", this.setError.getCacheDir());
                FileOutputStream fileOutputStream = new FileOutputStream(createTempFile);
                fieldValue.compress(Bitmap.CompressFormat.JPEG, 100, fileOutputStream);
                fileOutputStream.close();
                return createTempFile.getAbsolutePath();
            } catch (IOException e) {
                Log.w(setOptions, "Unable to create temporary file and store bitmap! " + e);
            }
        }
        return null;
    }

    public void read() {
        this.setError.finish();
    }

    protected void setOptions() {
        if (this.RemoteActionCompatParcelizer.setOptions().MediaDescriptionCompat()) {
            read();
        } else {
            this.setElement = true;
        }
        this.RemoteActionCompatParcelizer.write();
        this.AudioAttributesImplApi21Parcelizer.cancel();
    }

    private void MediaBrowserCompatCustomActionResultReceiver() {
        Intent intent = new Intent(Intents.Scan.ACTION);
        intent.putExtra(Intents.Scan.MISSING_CAMERA_PERMISSION, true);
        this.setError.setResult(0, intent);
    }

    protected void write() {
        Intent intent = new Intent(Intents.Scan.ACTION);
        intent.putExtra(Intents.Scan.TIMEOUT, true);
        this.setError.setResult(0, intent);
        setOptions();
    }

    protected void setFieldValue(renderTypeArguments rendertypearguments) {
        this.setError.setResult(-1, setOptions(rendertypearguments, setError(rendertypearguments)));
        setOptions();
    }

    protected void setFieldValue(String str) {
        if (this.setError.isFinishing() || this.IconCompatParcelizer || this.setElement) {
            return;
        }
        if (str.isEmpty()) {
            str = this.setError.getString(R.string.zxing_msg_camera_framework_bug);
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(this.setError);
        builder.setTitle(this.setError.getString(R.string.zxing_app_name));
        builder.setMessage(str);
        builder.setPositiveButton(R.string.zxing_button_ok, new DialogInterface.OnClickListener() {
            @Override
            public final void onClick(DialogInterface dialogInterface, int i) {
                setClassifierNamePolicy.this.setOptions(dialogInterface, i);
            }
        });
        builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
            @Override
            public final void onCancel(DialogInterface dialogInterface) {
                setClassifierNamePolicy.this.setLabel(dialogInterface);
            }
        });
        builder.show();
    }

    public void setOptions(DialogInterface dialogInterface, int i) {
        read();
    }

    public void setLabel(DialogInterface dialogInterface) {
        read();
    }

    public static int setFieldValue() {
        return setLabel;
    }

    public static void setBackground(int i) {
        setLabel = i;
    }

    public void setOptions(boolean z) {
        setLabel(z, "");
    }

    public void setLabel(boolean z, String str) {
        this.MediaBrowserCompatSearchResultReceiver = z;
        if (str == null) {
            str = "";
        }
        this.AudioAttributesImplBaseParcelizer = str;
    }
}