diff --git a/image-editor/app/.gitignore b/image-editor/app/.gitignore
new file mode 100644
index 000000000..42afabfd2
--- /dev/null
+++ b/image-editor/app/.gitignore
@@ -0,0 +1 @@
+/build
\ No newline at end of file
diff --git a/image-editor/app/build.gradle b/image-editor/app/build.gradle
new file mode 100644
index 000000000..c54e9cd8b
--- /dev/null
+++ b/image-editor/app/build.gradle
@@ -0,0 +1,49 @@
+plugins {
+ id 'com.android.application'
+ id 'kotlin-android'
+ id 'kotlin-kapt'
+ id 'witness'
+}
+
+apply from: 'witness-verifications.gradle'
+
+android {
+ compileSdk COMPILE_SDK
+
+ defaultConfig {
+ applicationId "org.signal.imageeditor.app"
+ versionCode 1
+ versionName "1.0"
+
+ minSdk MINIMUM_SDK
+ targetSdk TARGET_SDK
+ }
+
+ buildTypes {
+ release {
+ minifyEnabled false
+ proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+ }
+ }
+ compileOptions {
+ sourceCompatibility JAVA_VERSION
+ targetCompatibility JAVA_VERSION
+ }
+ kotlinOptions {
+ jvmTarget = '1.8'
+ }
+}
+
+dependencyVerification {
+ configuration = '(debug|release)RuntimeClasspath'
+}
+
+dependencies {
+ implementation libs.androidx.core.ktx
+ implementation libs.androidx.appcompat
+ implementation libs.material.material
+ implementation project(':image-editor')
+
+ implementation libs.glide.glide
+ kapt libs.glide.compiler
+}
\ No newline at end of file
diff --git a/image-editor/app/proguard-rules.pro b/image-editor/app/proguard-rules.pro
new file mode 100644
index 000000000..481bb4348
--- /dev/null
+++ b/image-editor/app/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/image-editor/app/src/androidTest/java/com/example/imageeditor/app/ExampleInstrumentedTest.kt b/image-editor/app/src/androidTest/java/com/example/imageeditor/app/ExampleInstrumentedTest.kt
new file mode 100644
index 000000000..f3e60adf1
--- /dev/null
+++ b/image-editor/app/src/androidTest/java/com/example/imageeditor/app/ExampleInstrumentedTest.kt
@@ -0,0 +1,24 @@
+package com.example.imageeditor.app
+
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
+
+import org.junit.Test
+import org.junit.runner.RunWith
+
+import org.junit.Assert.*
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@RunWith(AndroidJUnit4::class)
+class ExampleInstrumentedTest {
+ @Test
+ fun useAppContext() {
+ // Context of the app under test.
+ val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+ assertEquals("com.example.imageeditor.app", appContext.packageName)
+ }
+}
\ No newline at end of file
diff --git a/image-editor/app/src/main/AndroidManifest.xml b/image-editor/app/src/main/AndroidManifest.xml
new file mode 100644
index 000000000..2102741cd
--- /dev/null
+++ b/image-editor/app/src/main/AndroidManifest.xml
@@ -0,0 +1,28 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/image-editor/app/src/main/java/org/signal/imageeditor/app/MainActivity.java b/image-editor/app/src/main/java/org/signal/imageeditor/app/MainActivity.java
new file mode 100644
index 000000000..cb5a2d5e7
--- /dev/null
+++ b/image-editor/app/src/main/java/org/signal/imageeditor/app/MainActivity.java
@@ -0,0 +1,275 @@
+package org.signal.imageeditor.app;
+
+import android.Manifest;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Environment;
+import android.provider.MediaStore;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.appcompat.widget.Toolbar;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+
+import org.signal.imageeditor.app.renderers.UriRenderer;
+import org.signal.imageeditor.app.renderers.UrlRenderer;
+import org.signal.imageeditor.core.ImageEditorView;
+import org.signal.imageeditor.core.UndoRedoStackListener;
+import org.signal.imageeditor.core.model.EditorElement;
+import org.signal.imageeditor.core.model.EditorModel;
+import org.signal.imageeditor.core.renderers.MultiLineTextRenderer;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Locale;
+
+public final class MainActivity extends AppCompatActivity {
+
+ private static final String TAG = "MainActivity";
+
+ private ImageEditorView imageEditorView;
+ private Menu menu;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.main_activity);
+
+ Toolbar toolbar = findViewById(R.id.toolbar);
+ toolbar.setTitle(R.string.app_name_short);
+ setSupportActionBar(toolbar);
+
+ imageEditorView = findViewById(R.id.image_editor);
+
+ imageEditorView.setUndoRedoStackListener((undoAvailable, redoAvailable) -> {
+ Log.d("ALAN", String.format("Undo/Redo available: %s, %s", undoAvailable ? "Y" : "N", redoAvailable ? "Y" : "N"));
+ if (menu == null) return;
+ MenuItem undo = menu.findItem(R.id.action_undo);
+ MenuItem redo = menu.findItem(R.id.action_redo);
+ if (undo != null) undo.setVisible(undoAvailable);
+ if (redo != null) redo.setVisible(redoAvailable);
+ });
+
+ EditorModel model = null;
+ if (savedInstanceState != null) {
+ model = savedInstanceState.getParcelable("MODEL");
+ Log.d("ALAN", "Restoring instance " + (model != null ? model.hashCode() : 0));
+ }
+
+ if (model == null) {
+ model = initialModel();
+ Log.d("ALAN", "New instance created " + model.hashCode());
+ }
+
+ imageEditorView.setModel(model);
+
+ imageEditorView.setTapListener(new ImageEditorView.TapListener() {
+ @Override
+ public void onEntityDown(@Nullable EditorElement editorElement) {
+ Log.d("ALAN", "Entity down " + editorElement);
+ }
+
+ @Override
+ public void onEntitySingleTap(@Nullable EditorElement editorElement) {
+ Log.d("ALAN", "Entity single tapped " + editorElement);
+ }
+
+ @Override
+ public void onEntityDoubleTap(@NonNull EditorElement editorElement) {
+ Log.d("ALAN", "Entity double tapped " + editorElement);
+ if (editorElement.getRenderer() instanceof MultiLineTextRenderer) {
+ imageEditorView.startTextEditing(editorElement);
+ } else {
+ imageEditorView.deleteElement(editorElement);
+ }
+ }
+ });
+ }
+
+ private static EditorModel initialModel() {
+
+ EditorModel model = EditorModel.create();
+
+ EditorElement image = new EditorElement(new UrlRenderer("https://cdn.aarp.net/content/dam/aarp/home-and-family/your-home/2018/06/1140-house-inheriting.imgcache.rev68c065601779c5d76b913cf9ec3a977e.jpg"));
+ image.getFlags().setSelectable(false).persist();
+ model.addElement(image);
+
+ EditorElement elementC = new EditorElement(new UrlRenderer("https://upload.wikimedia.org/wikipedia/commons/thumb/e/e0/SNice.svg/220px-SNice.svg.png"));
+ elementC.getLocalMatrix().postScale(0.2f, 0.2f);
+ //elementC.getLocalMatrix().postRotate(30);
+ model.addElement(elementC);
+
+ EditorElement elementE = new EditorElement(new UrlRenderer("https://www.vitalessentialsraw.com/assets/images/background-images/laying-grey-cat.png"));
+ elementE.getLocalMatrix().postScale(0.2f, 0.2f);
+ //elementE.getLocalMatrix().postRotate(60);
+ model.addElement(elementE);
+
+ EditorElement elementD = new EditorElement(new UrlRenderer("https://petspluslubbocktx.com/files/2016/11/DC-Cat-Weight-Management.png"));
+ elementD.getLocalMatrix().postScale(0.2f, 0.2f);
+ //elementD.getLocalMatrix().postRotate(60);
+ model.addElement(elementD);
+
+ EditorElement elementF = new EditorElement(new UrlRenderer("https://purepng.com/public/uploads/large/purepng.com-black-top-hathatsstandard-sizeblacktop-14215263591972x0zh.png"));
+ elementF.getLocalMatrix().postScale(0.2f, 0.2f);
+ //elementF.getLocalMatrix().postRotatF(60);
+ model.addElement(elementF);
+
+ EditorElement elementG = new EditorElement(new UriRenderer(Uri.parse("file:///android_asset/food/apple.png")));
+ elementG.getLocalMatrix().postScale(0.2f, 0.2f);
+ //elementG.getLocalMatrix().postRotatG(60);
+ model.addElement(elementG);
+
+ EditorElement elementH = new EditorElement(new MultiLineTextRenderer("Hello, World!", 0xff0000ff, MultiLineTextRenderer.Mode.REGULAR));
+ //elementH.getLocalMatrix().postScale(0.2f, 0.2f);
+ model.addElement(elementH);
+
+ EditorElement elementH2 = new EditorElement(new MultiLineTextRenderer("Hello, World 2!", 0xff0000ff, MultiLineTextRenderer.Mode.REGULAR));
+ //elementH.getLocalMatrix().postScale(0.2f, 0.2f);
+ model.addElement(elementH2);
+
+ return model;
+ }
+
+ @Override
+ public void onSaveInstanceState(Bundle outState) {
+ super.onSaveInstanceState(outState);
+ outState.putParcelable("MODEL", imageEditorView.getModel());
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ getMenuInflater().inflate(R.menu.action_menu, menu);
+ this.menu = menu;
+ return true;
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case R.id.action_undo:
+ imageEditorView.getModel().undo();
+ Log.d(TAG, String.format("Model is %s", imageEditorView.getModel().isChanged() ? "changed" : "unchanged"));
+ return true;
+
+ case R.id.action_redo:
+ imageEditorView.getModel().redo();
+ return true;
+
+ case R.id.action_crop:
+ imageEditorView.setMode(ImageEditorView.Mode.MoveAndResize);
+ imageEditorView.getModel().startCrop();
+ return true;
+
+ case R.id.action_done:
+ imageEditorView.setMode(ImageEditorView.Mode.MoveAndResize);
+ imageEditorView.getModel().doneCrop();
+ return true;
+
+ case R.id.action_draw:
+ imageEditorView.setDrawingBrushColor(0xffffff00);
+ imageEditorView.startDrawing(0.02f, Paint.Cap.ROUND, false);
+ return true;
+
+ case R.id.action_rotate_right_90:
+ imageEditorView.getModel().rotate90clockwise();
+ return true;
+
+ case R.id.action_rotate_left_90:
+ imageEditorView.getModel().rotate90anticlockwise();
+ return true;
+
+ case R.id.action_flip_horizontal:
+ imageEditorView.getModel().flipHorizontal();
+ return true;
+
+ case R.id.action_flip_vertical:
+ imageEditorView.getModel().flipVertical();
+ return true;
+
+ case R.id.action_edit_text:
+ editText();
+ return true;
+
+ case R.id.action_lock_crop_aspect:
+ imageEditorView.getModel().setCropAspectLock(!imageEditorView.getModel().isCropAspectLocked());
+ return true;
+
+ case R.id.action_save:
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ != PackageManager.PERMISSION_GRANTED) {
+ ActivityCompat.requestPermissions(this,
+ new String[]{ Manifest.permission.WRITE_EXTERNAL_STORAGE },
+ 0);
+ } else {
+ Bitmap bitmap = imageEditorView.getModel().render(this);
+ try {
+ Uri uri = saveBmp(bitmap);
+
+ Intent intent = new Intent();
+ intent.setAction(Intent.ACTION_VIEW);
+ intent.setDataAndType(uri, "image/*");
+ startActivity(intent);
+
+ } finally {
+ bitmap.recycle();
+ }
+ }
+ return true;
+
+ default:
+ return super.onOptionsItemSelected(item);
+ }
+ }
+
+ private void editText() {
+ imageEditorView.getModel().getRoot().findElement(new Matrix(), new Matrix(), (element, inverseMatrix) -> {
+ if (element.getRenderer() instanceof MultiLineTextRenderer) {
+ imageEditorView.startTextEditing(element);
+ return true;
+ }
+ return false;
+ }
+ );
+ }
+
+ private Uri saveBmp(Bitmap bitmap) {
+ String path = Environment.getExternalStorageDirectory().toString();
+
+ File filePath = new File(path);
+ File imageEditor = new File(filePath, "ImageEditor");
+ if (!imageEditor.exists()) {
+ imageEditor.mkdir();
+ }
+
+ int counter = 0;
+ File file;
+ do {
+ counter++;
+ file = new File(imageEditor, String.format(Locale.US, "ImageEditor_%03d.jpg", counter));
+ } while (file.exists());
+
+ try {
+ try (OutputStream stream = new FileOutputStream(file)) {
+ bitmap.compress(Bitmap.CompressFormat.JPEG, 90, stream);
+ }
+ return Uri.parse(MediaStore.Images.Media.insertImage(getContentResolver(), file.getAbsolutePath(), file.getName(), file.getName()));
+ } catch (FileNotFoundException e) {
+ throw new RuntimeException(e);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/image-editor/app/src/main/java/org/signal/imageeditor/app/TheAppGlideModule.java b/image-editor/app/src/main/java/org/signal/imageeditor/app/TheAppGlideModule.java
new file mode 100644
index 000000000..934542c77
--- /dev/null
+++ b/image-editor/app/src/main/java/org/signal/imageeditor/app/TheAppGlideModule.java
@@ -0,0 +1,10 @@
+package org.signal.imageeditor.app;
+
+import com.bumptech.glide.annotation.GlideModule;
+import com.bumptech.glide.module.AppGlideModule;
+
+@GlideModule
+public class TheAppGlideModule extends AppGlideModule {
+
+
+}
diff --git a/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/StandardHitTestRenderer.java b/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/StandardHitTestRenderer.java
new file mode 100644
index 000000000..008f9db21
--- /dev/null
+++ b/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/StandardHitTestRenderer.java
@@ -0,0 +1,12 @@
+package org.signal.imageeditor.app.renderers;
+
+import org.signal.imageeditor.core.Bounds;
+import org.signal.imageeditor.core.Renderer;
+
+public abstract class StandardHitTestRenderer implements Renderer {
+
+ @Override
+ public boolean hitTest(float x, float y) {
+ return Bounds.contains(x, y);
+ }
+}
diff --git a/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/UriRenderer.java b/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/UriRenderer.java
new file mode 100644
index 000000000..3f5fa6f1f
--- /dev/null
+++ b/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/UriRenderer.java
@@ -0,0 +1,138 @@
+package org.signal.imageeditor.app.renderers;
+
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Point;
+import android.graphics.RectF;
+import android.net.Uri;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
+import com.bumptech.glide.request.target.SimpleTarget;
+import com.bumptech.glide.request.transition.Transition;
+
+import org.signal.imageeditor.app.GlideApp;
+import org.signal.imageeditor.core.Bounds;
+import org.signal.imageeditor.core.Renderer;
+import org.signal.imageeditor.core.RendererContext;
+
+public final class UriRenderer implements Renderer, Parcelable {
+
+ private final Uri imageUri;
+
+ private final Paint paint = new Paint();
+
+ private final Matrix temp1 = new Matrix();
+ private final Matrix temp2 = new Matrix();
+
+ @Nullable
+ private Bitmap bitmap;
+
+ public UriRenderer(Uri imageUri) {
+ this.imageUri = imageUri;
+ paint.setAntiAlias(true);
+ }
+
+ private UriRenderer(Parcel in) {
+ this(Uri.parse(in.readString()));
+ }
+
+ @Override
+ public void render(@NonNull RendererContext rendererContext) {
+ if (bitmap != null && bitmap.isRecycled()) bitmap = null;
+
+ if (bitmap == null) {
+ GlideApp.with(rendererContext.context)
+ .asBitmap()
+ .load(imageUri)
+ .diskCacheStrategy(DiskCacheStrategy.ALL)
+ .into(new SimpleTarget() {
+ @Override
+ public void onResourceReady(@NonNull Bitmap resource, @Nullable Transition transition) {
+ setBitmap(resource);
+ rendererContext.rendererReady.onReady(UriRenderer.this, cropMatrix(resource), new Point(resource.getWidth(), resource.getHeight()));
+ }
+ });
+ }
+
+ if (bitmap != null) {
+ rendererContext.save();
+ rendererContext.canvasMatrix.concat(temp1);
+
+ // FYI units are pixels at this point.
+ paint.setAlpha(rendererContext.getAlpha(255));
+ rendererContext.canvas.drawBitmap(bitmap, 0, 0, paint);
+ rendererContext.restore();
+ } else {
+ rendererContext.canvas.drawRect(-0.5f, -0.5f, 0.5f, 0.5f, paint);
+ }
+ }
+
+ @Override
+ public boolean hitTest(float x, float y) {
+ return pixelNotAlpha(x, y);
+ }
+
+ private boolean pixelNotAlpha(float x, float y) {
+ if (bitmap == null) return false;
+
+ temp1.invert(temp2);
+
+ float[] onBmp = new float[2];
+ temp2.mapPoints(onBmp, new float[]{ x, y });
+
+ int xInt = (int) onBmp[0];
+ int yInt = (int) onBmp[1];
+
+ if (xInt >= 0 && xInt < bitmap.getWidth() && yInt >= 0 && yInt < bitmap.getHeight()) {
+ return (bitmap.getPixel(xInt, yInt) & 0xff000000) != 0;
+ } else {
+ return false;
+ }
+ }
+
+ private void setBitmap(Bitmap bitmap) {
+ if (bitmap != null) {
+ this.bitmap = bitmap;
+ RectF from = new RectF(0, 0, bitmap.getWidth(), bitmap.getHeight());
+ temp1.setRectToRect(from, Bounds.FULL_BOUNDS, Matrix.ScaleToFit.CENTER);
+ }
+ }
+
+ private static Matrix cropMatrix(Bitmap bitmap) {
+ Matrix matrix = new Matrix();
+ if (bitmap.getWidth() > bitmap.getHeight()) {
+ matrix.preScale(1, ((float) bitmap.getHeight()) / bitmap.getWidth());
+ } else {
+ matrix.preScale(((float) bitmap.getWidth()) / bitmap.getHeight(), 1);
+ }
+ return matrix;
+ }
+
+ public static final Creator CREATOR = new Creator() {
+ @Override
+ public UriRenderer createFromParcel(Parcel in) {
+ return new UriRenderer(in);
+ }
+
+ @Override
+ public UriRenderer[] newArray(int size) {
+ return new UriRenderer[size];
+ }
+ };
+
+ @Override
+ public int describeContents() {
+ return 0;
+ }
+
+ @Override
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeString(imageUri.toString());
+ }
+}
diff --git a/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/UrlRenderer.java b/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/UrlRenderer.java
new file mode 100644
index 000000000..01d5f9ce5
--- /dev/null
+++ b/image-editor/app/src/main/java/org/signal/imageeditor/app/renderers/UrlRenderer.java
@@ -0,0 +1,263 @@
+package org.signal.imageeditor.app.renderers;
+
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Point;
+import android.graphics.RectF;
+import android.os.Parcel;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
+import com.bumptech.glide.request.target.SimpleTarget;
+import com.bumptech.glide.request.transition.Transition;
+
+import org.signal.imageeditor.app.GlideApp;
+import org.signal.imageeditor.core.Bounds;
+import org.signal.imageeditor.core.RendererContext;
+
+import java.util.concurrent.ExecutionException;
+
+public final class UrlRenderer extends StandardHitTestRenderer {
+
+ private static final String TAG = "UrlRenderer";
+ private final String url;
+ private final Paint paint = new Paint();
+
+ private final Matrix temp1 = new Matrix();
+ private final Matrix temp2 = new Matrix();
+
+ private Bitmap bitmap;
+
+ public UrlRenderer(@Nullable String url) {
+ this.url = url;
+ paint.setAntiAlias(true);
+ }
+
+ private UrlRenderer(Parcel in) {
+ this(in.readString());
+ }
+
+ public static final Creator CREATOR = new Creator() {
+ @Override
+ public UrlRenderer createFromParcel(Parcel in) {
+ return new UrlRenderer(in);
+ }
+
+ @Override
+ public UrlRenderer[] newArray(int size) {
+ return new UrlRenderer[size];
+ }
+ };
+
+ @Override
+ public void render(@NonNull RendererContext rendererContext) {
+ if (bitmap != null && bitmap.isRecycled()) bitmap = null;
+
+ if (bitmap == null) {
+ if (rendererContext.isBlockingLoad()) {
+ try {
+ setBitmap(rendererContext, GlideApp.with(rendererContext.context)
+ .asBitmap()
+ .load(url)
+ .diskCacheStrategy(DiskCacheStrategy.ALL)
+ .submit()
+ .get());
+ } catch (ExecutionException e) {
+ throw new RuntimeException(e);
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ } else {
+ GlideApp.with(rendererContext.context)
+ .asBitmap()
+ .load(url)
+ .diskCacheStrategy(DiskCacheStrategy.NONE)
+ .into(new SimpleTarget() {
+ @Override
+ public void onResourceReady(@NonNull Bitmap resource, @Nullable Transition transition) {
+ setBitmap(rendererContext, resource);
+ }
+ });
+ }
+ }
+
+ if (bitmap != null) {
+ rendererContext.save();
+ rendererContext.getCurrent(temp2);
+ temp2.preConcat(temp1);
+ rendererContext.canvas.concat(temp1);
+
+ // FYI units are pixels at this point.
+ paint.setAlpha(rendererContext.getAlpha(255));
+ rendererContext.canvas.drawBitmap(bitmap, 0, 0, paint);
+ rendererContext.restore();
+ } else {
+ if (rendererContext.isBlockingLoad()) {
+ Log.e(TAG, "blocking but drawing null :(");
+ }
+ rendererContext.canvas.drawRect(Bounds.FULL_BOUNDS, paint);
+ }
+
+ drawDebugInfo(rendererContext);
+ }
+
+ private void drawDebugInfo(RendererContext rendererContext) {
+// float width = bitmap.getWidth();
+// float height = bitmap.getWidth();
+
+ //RectF bounds = new RectF(Bounds.LEFT, Bounds.TOP/2f, Bounds.RIGHT,Bounds.BOTTOM/2f );//Bounds.FULL_BOUNDS;
+ RectF bounds = Bounds.FULL_BOUNDS;
+
+ Paint paint = new Paint();
+ paint.setStyle(Paint.Style.STROKE);
+ paint.setColor(0xffffff00);
+ rendererContext.canvas.drawRect(bounds, paint);
+
+ RectF fullBounds = new RectF();
+ rendererContext.mapRect(fullBounds, bounds);
+
+ rendererContext.save();
+
+ RectF dst = new RectF();
+ rendererContext.mapRect(dst, bounds);
+ paint.setColor(0xffff00ff);
+ rendererContext.canvasMatrix.setToIdentity();
+ rendererContext.canvas.drawRect(dst, paint);
+
+ rendererContext.restore();
+
+ rendererContext.save();
+
+ Matrix unrotated = new Matrix();
+ rendererContext.getCurrent(unrotated);
+ findUnrotateMatrix(unrotated);
+
+ Matrix rotated = new Matrix();
+ rendererContext.getCurrent(rotated);
+ findRotateMatrix(rotated);
+
+ RectF dst2 = new RectF();
+ unrotated.mapRect(dst2, Bounds.FULL_BOUNDS); // works because square, do we need rotated here?
+
+ float scaleX = Bounds.FULL_BOUNDS.width() / dst2.width();
+ float scaleY = Bounds.FULL_BOUNDS.height() / dst2.height();
+
+ rendererContext.canvasMatrix.concat(unrotated);
+ Matrix matrix = new Matrix();
+ matrix.setScale(scaleX, scaleY);
+ rendererContext.canvasMatrix.concat(matrix);
+
+ paint.setColor(0xff0000ff);
+ rendererContext.canvas.drawRect(bounds, paint);
+
+ rendererContext.restore();
+ }
+
+/**
+ * Given a scaled/rotated and transformed matrix, extract just the rotate and reverse it.
+ */
+ private void findUnrotateMatrix(@NonNull Matrix matrix) {
+ float[] values = new float[9];
+
+ matrix.getValues(values);
+
+ float xScale = (float) Math.sqrt(values[0] * values[0] + values[3] * values[3]);
+ float yScale = (float) Math.sqrt(values[1] * values[1] + values[4] * values[4]);
+
+ values[0] /= xScale;
+ values[1] /= -yScale;
+ values[2] = 0;
+
+ values[3] /= -xScale;
+ values[4] /= yScale;
+ values[5] = 0;
+
+ matrix.setValues(values);
+ }
+
+ /**
+ * Given a scaled/rotated and transformed matrix, extract just the rotate and reverse it.
+ */
+ private void findRotateMatrix(@NonNull Matrix matrix) {
+ float[] values = new float[9];
+
+ matrix.getValues(values);
+
+ float xScale = (float) Math.sqrt(values[0] * values[0] + values[3] * values[3]);
+ float yScale = (float) Math.sqrt(values[1] * values[1] + values[4] * values[4]);
+
+ values[0] /= xScale;
+ values[1] /= yScale;
+ values[2] = 0;
+
+ values[3] /= xScale;
+ values[4] /= yScale;
+ values[5] = 0;
+
+ matrix.setValues(values);
+ }
+
+ @Override
+ public boolean hitTest(float x, float y) {
+ return super.hitTest(x, y) && pixelNotAlpha(x, y);
+ }
+
+ private boolean pixelNotAlpha(float x, float y) {
+ if (bitmap == null) return false;
+
+ temp1.invert(temp2);
+
+ float[] onBmp = new float[2];
+ temp2.mapPoints(onBmp, new float[]{ x, y });
+
+ int xInt = (int) onBmp[0];
+ int yInt = (int) onBmp[1];
+
+ if (xInt >= 0 && xInt < bitmap.getWidth() && yInt >= 0 && yInt < bitmap.getHeight()) {
+ return (bitmap.getPixel(xInt, yInt) & 0xff000000) != 0;
+ } else {
+ return xInt >= 0 && xInt <= bitmap.getWidth() && yInt >= 0 && yInt <= bitmap.getHeight();
+ }
+ }
+
+ private void setBitmap(@NonNull RendererContext rendererContext, @Nullable Bitmap bitmap) {
+ this.bitmap = bitmap;
+ if (bitmap != null) {
+ RectF from = new RectF(0, 0, bitmap.getWidth(), bitmap.getHeight());
+ temp1.setRectToRect(from, Bounds.FULL_BOUNDS, Matrix.ScaleToFit.CENTER);
+ rendererContext.rendererReady.onReady(this, cropMatrix(bitmap), new Point(bitmap.getWidth(), bitmap.getHeight()));
+ }
+ }
+
+ private void setBitmap(Bitmap bitmap) {
+ if (bitmap != null) {
+ this.bitmap = bitmap;
+ RectF from = new RectF(0, 0, bitmap.getWidth(), bitmap.getHeight());
+ temp1.setRectToRect(from, Bounds.FULL_BOUNDS, Matrix.ScaleToFit.CENTER);
+ }
+ }
+
+ private static Matrix cropMatrix(Bitmap bitmap) {
+ Matrix matrix = new Matrix();
+ if (bitmap.getWidth() > bitmap.getHeight()) {
+ matrix.preScale(1, ((float) bitmap.getHeight()) / bitmap.getWidth());
+ } else {
+ matrix.preScale(((float) bitmap.getWidth()) / bitmap.getHeight(), 1);
+ }
+ return matrix;
+ }
+
+ @Override
+ public int describeContents() {
+ return 0;
+ }
+
+ @Override
+ public void writeToParcel(Parcel dest, int flags) {
+ dest.writeString(url);
+ }
+}
diff --git a/image-editor/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/image-editor/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
new file mode 100644
index 000000000..2b068d114
--- /dev/null
+++ b/image-editor/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
@@ -0,0 +1,30 @@
+
+
+
+
+