scoplan.camera 1.2.5

package/src/android/CameraSeekBarListener.java

@@ -0,0 +1,105 @@
+package scoplan.camera;
+
+import android.graphics.Rect;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Handler;
+import android.util.Log;
+import android.widget.SeekBar;
+
+public class CameraSeekBarListener implements SeekBar.OnSeekBarChangeListener {
+    private String currentCameraId;
+    private CameraManager cameraManager;
+    private SeekBar seekBar;
+    private CaptureRequest.Builder captureRequestBuilder;
+    private CameraCaptureSession cameraCaptureSessions;
+    private Handler mBackgroundHandler;
+    private float minZoom = 0;
+    private float maxZoom = 0;
+    int zoomStep = 1;
+    int zoomLevel = 0;
+
+    public CameraSeekBarListener(
+            String cameraId,
+            CameraManager cameraManager,
+            SeekBar seekBar,
+            CaptureRequest.Builder captureRequestBuilder,
+            CameraCaptureSession cameraCaptureSessions,
+            Handler mBackgroundHandler
+    ) {
+        currentCameraId = cameraId;
+        this.cameraManager = cameraManager;
+        this.seekBar = seekBar;
+        this.captureRequestBuilder = captureRequestBuilder;
+        this.cameraCaptureSessions = cameraCaptureSessions;
+        this.mBackgroundHandler = mBackgroundHandler;
+        this.maxZoom = this.getMaxZoom();
+        seekBar.setMax((int) maxZoom);
+        seekBar.setOnSeekBarChangeListener(this);
+    }
+    @Override
+    public void onProgressChanged(SeekBar seekBar, int progress, boolean b) {
+        setCurrentZoom(Math.round(minZoom + (progress * zoomStep)));
+    }
+
+    @Override
+    public void onStartTrackingTouch(SeekBar seekBar) {
+
+    }
+
+    @Override
+    public void onStopTrackingTouch(SeekBar seekBar) {
+
+    }
+
+    private Rect getZoomRect(float zoomLevel) {
+        try {
+            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(this.currentCameraId);
+            Rect activeRect = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+            if((zoomLevel <= maxZoom) && (zoomLevel > 1)) {
+                int minW = (int) (activeRect.width() / maxZoom);
+                int minH = (int) (activeRect.height() / maxZoom);
+                int difW = activeRect.width() - minW;
+                int difH = activeRect.height() - minH;
+                int cropW = difW / 100 * (int) zoomLevel;
+                int cropH = difH / 100 * (int) zoomLevel;
+                cropW -= cropW & 3;
+                cropH -= cropH & 3;
+                return new Rect(cropW, cropH, activeRect.width() - cropW, activeRect.height() - cropH);
+            } else if(zoomLevel == 0){
+                return new Rect(0, 0, activeRect.width(), activeRect.height());
+            }
+            return null;
+        } catch (Exception e) {
+            Log.e(scoplan.camera.CameraFragment.SCOPLAN_TAG, "Error during camera init");
+            return null;
+        }
+    }
+
+    public float getMaxZoom() {
+        try {
+            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(this.currentCameraId);
+            return characteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM) * 10;
+        } catch (CameraAccessException e) {
+            Log.e(scoplan.camera.CameraFragment.SCOPLAN_TAG, "Error during camera get zoom", e);
+        }
+        return 0;
+    }
+
+    public void setCurrentZoom(float zoomLevel) {
+        Rect zoomRect = getZoomRect(zoomLevel);
+        if(zoomRect != null) {
+            try {
+                //you can try to add the synchronized object here
+                captureRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
+                cameraCaptureSessions.setRepeatingRequest(captureRequestBuilder.build(), null, mBackgroundHandler);
+            } catch (Exception e) {
+                Log.e(scoplan.camera.CameraFragment.SCOPLAN_TAG, "Error updating preview: ", e);
+            }
+            this.zoomLevel = (int) zoomLevel;
+        }
+    }
+}

package/src/android/CameraUtils.java

@@ -0,0 +1,94 @@
+package scoplan.camera;
+
+import android.graphics.Matrix;
+import android.graphics.SurfaceTexture;
+import android.hardware.camera2.CameraCharacteristics;
+import android.os.Build;
+import android.util.Size;
+import android.view.TextureView;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class CameraUtils {
+    /** Return the biggest preview size available which is smaller than the window */
+    private static Size findBestPreviewSize(Size windowSize, CameraCharacteristics characteristics) {
+        List<Size> supportedPreviewSizes = new ArrayList<>();
+        Size[] sizes = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
+                .getOutputSizes(SurfaceTexture.class);
+        if(sizes != null) {
+            for(Size a : sizes) {
+                if(windowSize.getHeight() * windowSize.getWidth() - a.getWidth() * a.getHeight() > 0) {
+                    supportedPreviewSizes.add(a);
+                }
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                supportedPreviewSizes.sort(new SizeComparator());
+            }
+        }
+        return supportedPreviewSizes.size() > 0 ? supportedPreviewSizes.get(0) : new Size(0, 0);
+    }
+
+    public static SurfaceTexture buildTargetTexture(TextureView textureView, CameraCharacteristics characteristics, int surfaceRotation) {
+        int surfaceRotationDegrees = surfaceRotation * 90;
+        Size windowSize = new Size(textureView.getWidth(), textureView.getHeight());
+        Size previewSize = CameraUtils.findBestPreviewSize(windowSize, characteristics);
+        int sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+        boolean isRotationRequired = CameraUtils.computeRelativeRotation(characteristics, surfaceRotationDegrees) % 180 != 0;
+        float scaleX = 1f;
+        float scaleY = 1f;
+        if(sensorOrientation == 0) {
+            scaleX = isRotationRequired ? windowSize.getWidth() / previewSize.getWidth() : windowSize.getWidth() / previewSize.getHeight();
+            scaleY = isRotationRequired ? windowSize.getHeight() / previewSize.getHeight() : windowSize.getHeight() / previewSize.getWidth();
+        } else {
+            scaleX = isRotationRequired ? windowSize.getWidth() / previewSize.getHeight() : windowSize.getWidth() / previewSize.getWidth();
+            scaleY = isRotationRequired ? windowSize.getHeight() / previewSize.getWidth() : windowSize.getHeight() / previewSize.getHeight();
+        }
+        float finalScale = Math.max(scaleX, scaleY);
+        float halfWidth = windowSize.getWidth() / 2f;
+        float halfHeight = windowSize.getHeight() / 2f;
+        Matrix matrix = new Matrix();
+        if(isRotationRequired) {
+            matrix.setScale(
+            1/ scaleX * finalScale,
+            1/ scaleY * finalScale,
+                halfWidth,
+                halfHeight
+            );
+        } else {
+            matrix.setScale(
+                    windowSize.getHeight() / windowSize.getWidth() / scaleY * finalScale,
+                    windowSize.getWidth() / windowSize.getHeight() / scaleX * finalScale,
+                    halfWidth,
+                    halfHeight
+            );
+        }
+        // Rotate to compensate display rotation
+        matrix.postRotate(
+            -surfaceRotationDegrees,
+            halfWidth,
+            halfHeight
+        );
+
+        textureView.setTransform(matrix);
+
+        SurfaceTexture texture = textureView.getSurfaceTexture();
+        assert  texture != null;
+        texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
+
+        return texture;
+    }
+
+    public static int computeRelativeRotation(CameraCharacteristics cameraCharacteristics, int deviceOrientationDegrees) {
+        int sensorOrientationDegrees = cameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+        int sign = cameraCharacteristics.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT ? 1 : -1;
+        return (sensorOrientationDegrees - (deviceOrientationDegrees * sign) + 360) % 360;
+    }
+}
+class SizeComparator implements Comparator<Size> {
+    @Override
+    public int compare(Size a, Size b) {
+        return b.getHeight() * b.getWidth() - a.getWidth() * a.getHeight();
+    }
+}

package/src/android/CustomI.java

@@ -0,0 +1,37 @@
+package scoplan.camera;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.NonNull;
+
+import com.dsphotoeditor.sdk.ui.stickerview.i;
+
+import java.util.ArrayList;
+
+public class CustomI extends i {
+    public CustomI(@NonNull Context context) {
+        super(context);
+    }
+    public static ArrayList<Drawable> drawables;
+    private int index = 0;
+    @Override
+    @NonNull
+    public i a(@ColorInt int var1) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            drawables.get(this.index).setTint(var1);
+        }
+        return super.a(var1);
+    }
+
+    @Override
+    public i a(@NonNull Drawable var1) {
+        if(drawables == null)
+            drawables = new ArrayList<Drawable>();
+        this.drawables.add(var1);
+        this.index = this.drawables.size() - 1;
+        return super.a(var1);
+    }
+}

package/src/android/FakeR.java

@@ -0,0 +1,31 @@
+package scoplan.camera;
+
+import android.content.Context;
+
+public class FakeR {
+    private Context context;
+
+    public FakeR(Context context) {
+        this.context = context;
+    }
+
+    public int getId(String key) {
+        return getResourceId(context, "id", key);
+    }
+
+    public int getString(String key) {
+        return getResourceId(context, "string", key);
+    }
+
+    public int getDrawable(String key) {
+        return getResourceId(context, "drawable", key);
+    }
+
+    public int getLayout(String key) {
+        return getResourceId(context, "layout", key);
+    }
+
+    public static int getResourceId(Context context, String group, String key) {
+        return context.getResources().getIdentifier(key, group, context.getPackageName());
+    }
+}

package/src/android/ImageCameraAvailableListener.java

@@ -0,0 +1,65 @@
+package scoplan.camera;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
+import android.media.Image;
+import android.media.ImageReader;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+
+public class ImageCameraAvailableListener implements ImageReader.OnImageAvailableListener {
+    private ImageReader reader;
+    private File file;
+    private scoplan.camera.OnImageCaptureListener imageCaptureListener;
+    private float rotation;
+
+    public ImageCameraAvailableListener(File file, ImageReader reader, scoplan.camera.OnImageCaptureListener onImageCaptureListener, float rotation) {
+        this.reader = reader;
+        this.file = file;
+        this.imageCaptureListener = onImageCaptureListener;
+        this.rotation = rotation;
+    }
+    @Override
+    public void onImageAvailable(ImageReader imageReader) {
+        Image image = null;
+        try{
+            image = reader.acquireLatestImage();
+            ByteBuffer buffer = image.getPlanes()[0].getBuffer();
+            byte[] bytes = new byte[buffer.capacity()];
+            buffer.get(bytes);
+            this.imageCaptureListener.onImageCapture(file, save(bytes));
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+            this.imageCaptureListener.onImageBuildFailed(e);
+        }
+        finally {
+            {
+                if(image != null)
+                    image.close();
+            }
+        }
+    }
+
+    private Bitmap save(byte[] bytes) throws IOException {
+        OutputStream outputStream = null;
+        try{
+            outputStream = new FileOutputStream(file);
+            Bitmap bmp = BitmapFactory.decodeByteArray(bytes,0, bytes.length);
+            Matrix matrix = new Matrix();
+            matrix.setRotate(this.rotation);
+            Bitmap rotatedBitmap = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true);
+            rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 65, outputStream);
+            return rotatedBitmap;
+        } finally {
+            if(outputStream != null)
+                outputStream.close();
+        }
+    }
+}

package/src/android/OnImageCaptureListener.java

@@ -0,0 +1,11 @@
+package scoplan.camera;
+
+import android.graphics.Bitmap;
+
+import java.io.File;
+
+public interface OnImageCaptureListener {
+    public void onImageCapture(File file, Bitmap bitmap);
+
+    public void onImageBuildFailed(Exception e);
+}

package/src/android/PhotoEditorActivity.java

@@ -0,0 +1,128 @@
+package scoplan.camera;
+
+import android.annotation.SuppressLint;
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
+import android.widget.Toast;
+
+import com.dsphotoeditor.sdk.activity.DsPhotoEditorActivity;
+
+import java.io.File;
+
+public class PhotoEditorActivity extends DsPhotoEditorActivity {
+    private Uri e;
+
+    private FakeR fakeR;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        Context context = getApplicationContext();
+        int themeId = context.getResources().getIdentifier("AppTheme.NoActionBar", "style", context.getPackageName());
+        setTheme(themeId);
+        super.onCreate(savedInstanceState);
+        this.fakeR = new FakeR(this);
+        this.e = this.getIntent().getData();
+        if (this.e == null) {
+            Toast.makeText(this, this.getString(com.dsphotoeditor.sdk.R.string.ds_photo_editor_error_no_uri), Toast.LENGTH_LONG).show();
+            this.finish();
+        } else {
+            this.createBottomBar(savedInstanceState);
+        }
+    }
+
+    @SuppressLint("ResourceType")
+    private void createBottomBar(Bundle var1) {
+        if (super.findViewById(fakeR.getId("ds_photo_editor_bottom_bar_fragment_container")) != null) {
+            View super_bottom_bar = super.findViewById(fakeR.getId("ds_photo_editor_bottom_bar_fragment_container"));
+            super_bottom_bar.setVisibility(View.INVISIBLE);
+            View custom_bottom_bar = new FrameLayout(this);
+            RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, super_bottom_bar.getLayoutParams().height);
+            lp.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
+            custom_bottom_bar.setLayoutParams(lp);
+            custom_bottom_bar.setId(12345678);
+            ((RelativeLayout) super.findViewById(fakeR.getId("ds_photo_editor_root_layout"))).addView(custom_bottom_bar);
+            PhotoEditorMenu var2 = new PhotoEditorMenu();
+            var2.setArguments(super.getIntent().getExtras());
+            super.getFragmentManager().beginTransaction().add(custom_bottom_bar.getId(), var2, "custom_bottom_fragment_tag").commit();
+        }
+    }
+
+    public void onClick(View var1) {
+        int var2 = this.getFragmentManager().getBackStackEntryCount();
+        if (var1.getId() == com.dsphotoeditor.sdk.R.id.ds_photo_editor_top_button_apply) {
+            if (var2 == 0) {
+                if (this.getHdBitmap() != null && !this.isLoadingIndicatorShowing()) {
+                    a var3 = new a();
+                    var3.execute(new Bitmap[]{this.getHdBitmap()});
+                }
+            } else if (!this.isLoadingIndicatorShowing()) {
+                this.getFragmentManager().popBackStack();
+                this.updateTopbarTitle(this.getString(com.dsphotoeditor.sdk.R.string.ds_photo_editor_main_title));
+                if (this.toolType == 7) {
+                    this.setHdBitmap(com.dsphotoeditor.sdk.b.d.a);
+                    com.dsphotoeditor.sdk.b.d.a = null;
+                }
+                com.dsphotoeditor.sdk.a.a var4 = new com.dsphotoeditor.sdk.a.a(this, this.filterLutIdValue, this.frameIdValue, this.seekBarValue);
+                var4.execute(new Integer[]{this.toolType});
+            }
+        } else {
+            super.onClick(var1);
+        }
+    }
+
+    private class a extends AsyncTask<Bitmap, Void, File> {
+        private ProgressDialog b;
+
+        private a() {
+        }
+
+        @Override
+        protected File doInBackground(Bitmap... bitmaps) {
+            return a(bitmaps);
+        }
+
+        protected void onPreExecute() {
+            super.onPreExecute();
+            this.b = com.dsphotoeditor.sdk.utils.c.a(PhotoEditorActivity.this, PhotoEditorActivity.this.getString(com.dsphotoeditor.sdk.R.string.ds_photo_editor_finish_up_loading_indicator), 1, false);
+            if (!this.b.isShowing()) {
+                this.b.show();
+            }
+
+        }
+
+        protected File a(Bitmap... var1) {
+            Bitmap var2 = var1[0];
+            File var3 = scoplan.camera.PhotoEditorStore.a(PhotoEditorActivity.this, var2);
+            return var3;
+        }
+
+        @Override
+        protected void onPostExecute(File file) {
+            a(file);
+        }
+
+        protected void a(File var1) {
+            super.onPostExecute(var1);
+            if (this.b != null && this.b.isShowing()) {
+                this.b.dismiss();
+            }
+
+            if (var1 != null) {
+                Uri var2 = Uri.fromFile(var1);
+                Intent var3 = new Intent();
+                var3.setData(var2);
+                PhotoEditorActivity.this.setResult(-1, var3);
+            }
+
+            PhotoEditorActivity.this.finish();
+        }
+    }
+}

package/src/android/PhotoEditorMenu.java

@@ -0,0 +1,111 @@
+package scoplan.camera;
+
+import static android.app.Activity.RESULT_OK;
+
+import android.app.AlertDialog;
+import android.app.Fragment;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+
+import androidx.annotation.Nullable;
+
+import com.dsphotoeditor.sdk.activity.DsPhotoEditorActivity;
+import com.dsphotoeditor.sdk.activity.DsPhotoEditorCropActivity;
+import com.dsphotoeditor.sdk.activity.DsPhotoEditorDrawActivity;
+import com.dsphotoeditor.sdk.activity.DsPhotoEditorTextActivity;
+
+public class PhotoEditorMenu extends Fragment implements View.OnClickListener {
+
+    // TODO: Rename parameter arguments, choose names that match
+    // the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
+    private DsPhotoEditorActivity a;
+    private LinearLayout c;
+    int[] clickableButton;
+    private FakeR fakeR;
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        this.fakeR = new FakeR(getActivity());
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater var1, ViewGroup var2, Bundle var3) {
+        View var4 = var1.inflate(fakeR.getLayout("fragment_photo_editor_menu"), var2, false);
+        clickableButton = new int[] {
+            fakeR.getId("ds_photo_editor_btn_crop"),
+            fakeR.getId("ds_photo_editor_btn_sticker"),
+            fakeR.getId("ds_photo_editor_btn_text"),
+            fakeR.getId("ds_photo_editor_btn_draw"),
+            fakeR.getId("ds_photo_editor_btn_remove"),
+        };
+        this.a = (DsPhotoEditorActivity) this.getActivity();
+        this.c = var4.findViewById(fakeR.getId("custom_photo_editor_bar_bottom_container"));
+        int var6;
+        for(var6 = 0; var6 < clickableButton.length; ++var6) {
+            this.c.findViewById(clickableButton[var6]).setOnClickListener(this);
+        }
+        return var4;
+    }
+
+    public void onClick(View var1) {
+        int var2 = var1.getId();
+        DsPhotoEditorActivity var10000;
+        Intent var3;
+        if(var2 == fakeR.getId("ds_photo_editor_btn_crop")) {
+            DsPhotoEditorActivity.intentResult = null;
+            DsPhotoEditorCropActivity.original = this.a.getHdBitmap();
+            var3 = new Intent(this.a, CCropActivity.class);
+            var10000 = this.a;
+            this.a.getClass();
+            var10000.startActivityForResult(var3, 3);
+            this.a.toolType = 6;
+        } else if(var2 == fakeR.getId("ds_photo_editor_btn_sticker")) {
+            DsPhotoEditorActivity.intentResult = null;
+            PhotoEditorMesureCustomActivity.original = this.a.getHdBitmap();
+            var3 = new Intent(this.a, PhotoEditorMesureCustomActivity.class);
+            var10000 = this.a;
+            this.a.getClass();
+            var10000.startActivityForResult(var3, 2);
+            this.a.toolType = 14;
+        } else if(var2 == fakeR.getId("ds_photo_editor_btn_text")) {
+            DsPhotoEditorActivity.intentResult = null;
+            DsPhotoEditorTextActivity.original = this.a.getHdBitmap();
+            var3 = new Intent(this.a, CTextActivity.class);
+            var10000 = this.a;
+            this.a.getClass();
+            var10000.startActivityForResult(var3, 2);
+            this.a.toolType = 14;
+        } else if(var2 == fakeR.getId("ds_photo_editor_btn_draw")) {
+            DsPhotoEditorActivity.intentResult = null;
+            DsPhotoEditorDrawActivity.original = this.a.getHdBitmap();
+            var3 = new Intent(this.a, CDrawActivity.class);
+            var10000 = this.a;
+            this.a.getClass();
+            var10000.startActivityForResult(var3, 4);
+            this.a.toolType = 12;
+        } else if(var2 == fakeR.getId("ds_photo_editor_btn_remove")) {
+            AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+            builder.setMessage("Voulez vous vraiment supprimer l'image?").setPositiveButton("Oui", new android.content.DialogInterface.OnClickListener() {
+                public void onClick(DialogInterface var1, int var2) {
+                    Intent data = new Intent();
+                    String result = "remove";
+                    data.setData(Uri.parse(result));
+                    getActivity().setResult(RESULT_OK, data);
+                    getActivity().finish();
+                }
+            }).setNegativeButton("Annuler", new android.content.DialogInterface.OnClickListener() {
+                public void onClick(DialogInterface var1, int var2) {
+                }
+            });
+            builder.create().show();
+        }
+    }
+}