智能工厂.apk(点击下载) / ZBarScannerActivity.java


package org.cloudsky.cordovaPlugins;

import android.app.Activity;
import android.content.Intent;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.hardware.Camera;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.TextView;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import net.sourceforge.zbar.Image;
import net.sourceforge.zbar.ImageScanner;
import net.sourceforge.zbar.Symbol;
import org.json.JSONException;
import org.json.JSONObject;

public class ZBarScannerActivity extends Activity implements SurfaceHolder.Callback {
    private static final int CAMERA_PERMISSION_REQUEST = 1;
    public static final String EXTRA_PARAMS = "params";
    public static final String EXTRA_QRVALUE = "qrValue";
    public static final int RESULT_ERROR = 2;
    private static int autoFocusInterval = 2000;
    private Camera.AutoFocusCallback autoFocusCb = new Camera.AutoFocusCallback() {
        /* class org.cloudsky.cordovaPlugins.ZBarScannerActivity.AnonymousClass2 */

        public void onAutoFocus(boolean z, Camera camera) {
            try {
                camera.cancelAutoFocus();
                ZBarScannerActivity.this.autoFocusHandler.postDelayed(ZBarScannerActivity.this.doAutoFocus, (long) ZBarScannerActivity.autoFocusInterval);
            } catch (Exception unused) {
            }
        }
    };
    private Handler autoFocusHandler;
    private Camera camera;
    private Runnable doAutoFocus = new Runnable() {
        /* class org.cloudsky.cordovaPlugins.ZBarScannerActivity.AnonymousClass3 */

        public void run() {
            if (ZBarScannerActivity.this.camera != null) {
                ZBarScannerActivity.this.camera.autoFocus(ZBarScannerActivity.this.autoFocusCb);
            }
        }
    };
    String flashMode;
    private SurfaceHolder holder;
    private Collection<ZBarcodeFormat> mFormats = null;
    private String package_name;
    private Camera.PreviewCallback previewCb = new Camera.PreviewCallback() {
        /* class org.cloudsky.cordovaPlugins.ZBarScannerActivity.AnonymousClass4 */

        public void onPreviewFrame(byte[] bArr, Camera camera) {
            Camera.Size previewSize = camera.getParameters().getPreviewSize();
            Image image = new Image(previewSize.width, previewSize.height, "Y800");
            image.setData(bArr);
            if (ZBarScannerActivity.this.scanner.scanImage(image) != 0) {
                Iterator<Symbol> it = ZBarScannerActivity.this.scanner.getResults().iterator();
                while (it.hasNext()) {
                    Symbol next = it.next();
                    System.out.println("扫描结果");
                    System.out.println(next.getType());
                    System.out.println(next.getData());
                    String data = next.getData();
                    Intent intent = new Intent();
                    intent.putExtra(ZBarScannerActivity.EXTRA_QRVALUE, data);
                    ZBarScannerActivity.this.setResult(-1, intent);
                    ZBarScannerActivity.this.finish();
                }
            }
        }
    };
    private Resources resources;
    private ImageScanner scanner;
    private SurfaceView scannerSurface;
    private int surfH;
    private int surfW;
    String whichCamera;

    static {
        System.loadLibrary("iconv");
    }

    public void onCreate(Bundle bundle) {
        if (ContextCompat.checkSelfPermission(getBaseContext(), "android.permission.CAMERA") == 0) {
            setUpCamera();
        } else {
            ActivityCompat.requestPermissions(this, new String[]{"android.permission.CAMERA"}, 1);
        }
        super.onCreate(bundle);
    }

    public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
        if (i == 1) {
            if (iArr.length <= 0 || iArr[0] != 0) {
                onBackPressed();
            } else {
                setUpCamera();
            }
        }
    }

    private void setUpCamera() {
        JSONObject jSONObject;
        try {
            jSONObject = new JSONObject(getIntent().getStringExtra("params"));
        } catch (JSONException unused) {
            jSONObject = new JSONObject();
        }
        String optString = jSONObject.optString("text_title");
        String optString2 = jSONObject.optString("text_instructions");
        Boolean valueOf = Boolean.valueOf(jSONObject.optBoolean("drawSight", true));
        this.whichCamera = jSONObject.optString("camera");
        this.flashMode = jSONObject.optString("flash");
        this.autoFocusHandler = new Handler();
        this.scanner = new ImageScanner();
        this.scanner.setConfig(0, 256, 3);
        this.scanner.setConfig(0, 257, 3);
        this.scanner.setConfig(0, 0, 0);
        for (ZBarcodeFormat zBarcodeFormat : getFormats()) {
            this.scanner.setConfig(zBarcodeFormat.getId(), 0, 1);
        }
        setContentView(getResourceId("layout/cszbarscanner"));
        ((TextView) findViewById(getResourceId("id/csZbarScannerTitle"))).setText(optString);
        ((TextView) findViewById(getResourceId("id/csZbarScannerInstructions"))).setText(optString2);
        if (!valueOf.booleanValue()) {
            findViewById(getResourceId("id/csZbarScannerSight")).setVisibility(4);
        }
        this.scannerSurface = new SurfaceView(this) {
            /* class org.cloudsky.cordovaPlugins.ZBarScannerActivity.AnonymousClass1 */

            public void onSizeChanged(int i, int i2, int i3, int i4) {
                ZBarScannerActivity.this.surfW = i;
                ZBarScannerActivity.this.surfH = i2;
                ZBarScannerActivity.this.matchSurfaceToPreviewRatio();
            }
        };
        this.scannerSurface.setLayoutParams(new FrameLayout.LayoutParams(-1, -1, 17));
        this.scannerSurface.getHolder().addCallback(this);
        FrameLayout frameLayout = (FrameLayout) findViewById(getResourceId("id/csZbarScannerView"));
        frameLayout.addView(this.scannerSurface);
        findViewById(getResourceId("id/csZbarScannerTitle")).bringToFront();
        findViewById(getResourceId("id/csZbarScannerInstructions")).bringToFront();
        findViewById(getResourceId("id/csZbarScannerSightContainer")).bringToFront();
        findViewById(getResourceId("id/csZbarScannerSight")).bringToFront();
        frameLayout.requestLayout();
        frameLayout.invalidate();
    }

    public void onResume() {
        super.onResume();
        try {
            if (this.whichCamera.equals("front")) {
                int numberOfCameras = Camera.getNumberOfCameras();
                Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
                for (int i = 0; i < numberOfCameras; i++) {
                    Camera.getCameraInfo(i, cameraInfo);
                    if (cameraInfo.facing == 1) {
                        this.camera = Camera.open(i);
                    }
                }
            } else {
                this.camera = Camera.open();
            }
            if (this.camera == null) {
                throw new Exception("Error: No suitable camera found.");
            }
        } catch (RuntimeException unused) {
        } catch (Exception unused2) {
        }
    }

    private void setCameraDisplayOrientation(Activity activity, int i) {
        int i2;
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        Camera.getCameraInfo(i, cameraInfo);
        int i3 = 0;
        switch (activity.getWindowManager().getDefaultDisplay().getRotation()) {
            case 1:
                i3 = 90;
                break;
            case 2:
                i3 = 180;
                break;
            case 3:
                i3 = 270;
                break;
        }
        if (cameraInfo.facing == 1) {
            i2 = (360 - ((cameraInfo.orientation + i3) % 360)) % 360;
        } else {
            i2 = ((cameraInfo.orientation - i3) + 360) % 360;
        }
        this.camera.setDisplayOrientation(i2);
    }

    public void onPause() {
        releaseCamera();
        super.onPause();
    }

    public void onDestroy() {
        ImageScanner imageScanner = this.scanner;
        if (imageScanner != null) {
            imageScanner.destroy();
        }
        super.onDestroy();
    }

    public void onBackPressed() {
        setResult(0);
        super.onBackPressed();
    }

    public void surfaceCreated(SurfaceHolder surfaceHolder) {
        tryStopPreview();
        this.holder = surfaceHolder;
        tryStartPreview();
    }

    public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
        die("The camera surface was destroyed");
    }

    public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i2, int i3) {
        if (surfaceHolder.getSurface() == null) {
            die("There is no camera surface");
        }
        this.surfW = i2;
        this.surfH = i3;
        matchSurfaceToPreviewRatio();
        tryStopPreview();
        this.holder = surfaceHolder;
        tryStartPreview();
    }

    public void onConfigurationChanged(Configuration configuration) {
        super.onConfigurationChanged(configuration);
        int i = 90;
        switch (getWindowManager().getDefaultDisplay().getRotation()) {
            case 1:
                i = 0;
                break;
            case 2:
                i = 270;
                break;
            case 3:
                i = 180;
                break;
        }
        this.camera.setDisplayOrientation(i);
        this.camera.getParameters();
        tryStopPreview();
        tryStartPreview();
    }

    /* JADX WARNING: Failed to process nested try/catch */
    /* JADX WARNING: Missing exception handler attribute for start block: B:10:0x003a */
    /* JADX WARNING: Removed duplicated region for block: B:13:0x0053 A[Catch:{ RuntimeException -> 0x007b, IOException -> 0x0065 }] */
    public void toggleFlash(View view) {
        this.camera.startPreview();
        Camera.Parameters parameters = this.camera.getParameters();
        if (!parameters.getFlashMode().equals("off") || parameters.getFlashMode().equals("torch") || parameters.getFlashMode().equals("on")) {
            parameters.setFlashMode("off");
        } else {
            parameters.setFlashMode("torch");
        }
        try {
            this.camera.setPreviewDisplay(this.holder);
            this.camera.setPreviewCallback(this.previewCb);
            this.camera.startPreview();
            if (Build.VERSION.SDK_INT >= 14) {
                this.camera.autoFocus(this.autoFocusCb);
                parameters.setFocusMode("continuous-picture");
            }
            this.camera.setParameters(parameters);
        } catch (RuntimeException unused) {
            Log.d("csZBar", "Unsupported camera parameter reported for flash mode: " + this.flashMode);
        } catch (IOException unused2) {
            Log.d("csZBar", "Wrong holder data" + this.flashMode);
        }
    }

    private void die(String str) {
        setResult(2);
        finish();
    }

    private int getResourceId(String str) {
        if (this.package_name == null) {
            this.package_name = getApplication().getPackageName();
        }
        if (this.resources == null) {
            this.resources = getApplication().getResources();
        }
        return this.resources.getIdentifier(str, null, this.package_name);
    }

    private void releaseCamera() {
        if (this.camera != null) {
            this.autoFocusHandler.removeCallbacks(this.doAutoFocus);
            this.camera.setPreviewCallback(null);
            this.camera.release();
            this.camera = null;
        }
    }

    /* access modifiers changed from: private */
    /* access modifiers changed from: public */
    private void matchSurfaceToPreviewRatio() {
        Camera camera2 = this.camera;
        if (camera2 != null && this.surfW != 0 && this.surfH != 0) {
            Camera.Size previewSize = camera2.getParameters().getPreviewSize();
            float f = ((float) previewSize.height) / ((float) previewSize.width);
            int i = this.surfW;
            int i2 = this.surfH;
            float f2 = ((float) i) / ((float) i2);
            if (f > f2) {
                this.scannerSurface.setLayoutParams(new FrameLayout.LayoutParams(i, Math.round(((float) i) / f), 17));
            } else if (f < f2) {
                this.scannerSurface.setLayoutParams(new FrameLayout.LayoutParams(Math.round(((float) i2) * f), this.surfH, 17));
            }
        }
    }

    private void tryStopPreview() {
        try {
            this.camera.stopPreview();
        } catch (Exception unused) {
        }
    }

    public Collection<ZBarcodeFormat> getFormats() {
        Collection<ZBarcodeFormat> collection = this.mFormats;
        return collection == null ? ZBarcodeFormat.ALL_FORMATS : collection;
    }

    private void tryStartPreview() {
        if (this.holder != null) {
            try {
                switch (getWindowManager().getDefaultDisplay().getRotation()) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    default:
                        setCameraDisplayOrientation(this, 0);
                        Camera.Parameters parameters = this.camera.getParameters();
                        try {
                            parameters.setFocusMode("continuous-picture");
                            this.camera.setParameters(parameters);
                        } catch (Exception unused) {
                        }
                        this.camera.setPreviewDisplay(this.holder);
                        this.camera.setPreviewCallback(this.previewCb);
                        this.camera.startPreview();
                        if (Build.VERSION.SDK_INT >= 14) {
                            this.camera.autoFocus(this.autoFocusCb);
                            return;
                        }
                        return;
                }
            } catch (IOException e) {
                die("Could not start camera preview: " + e.getMessage());
            }
        }
    }
}