() {
+ @Override
+ public void set(final View view, final Integer visibility, int index) {
+ view.setVisibility(visibility);
+ }
+ };
+}
diff --git a/scissors-sample/src/main/java/com/lyft/android/scissorssample/RequestCodes.java b/scissors-sample/src/main/java/com/lyft/android/scissorssample/RequestCodes.java
new file mode 100644
index 0000000..c78cb57
--- /dev/null
+++ b/scissors-sample/src/main/java/com/lyft/android/scissorssample/RequestCodes.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissorssample;
+
+public interface RequestCodes {
+
+ int PICK_IMAGE_FROM_GALLERY = 10001;
+}
diff --git a/scissors-sample/src/main/res/layout/activity_crop_result.xml b/scissors-sample/src/main/res/layout/activity_crop_result.xml
new file mode 100644
index 0000000..5eaa212
--- /dev/null
+++ b/scissors-sample/src/main/res/layout/activity_crop_result.xml
@@ -0,0 +1,8 @@
+
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/layout/activity_main.xml b/scissors-sample/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..d50d322
--- /dev/null
+++ b/scissors-sample/src/main/res/layout/activity_main.xml
@@ -0,0 +1,48 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/mipmap-hdpi/ic_launcher.png b/scissors-sample/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100755
index 0000000..a68693f
Binary files /dev/null and b/scissors-sample/src/main/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/scissors-sample/src/main/res/mipmap-mdpi/ic_launcher.png b/scissors-sample/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100755
index 0000000..cbf6201
Binary files /dev/null and b/scissors-sample/src/main/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/scissors-sample/src/main/res/mipmap-xhdpi/ic_launcher.png b/scissors-sample/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100755
index 0000000..79676ae
Binary files /dev/null and b/scissors-sample/src/main/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/scissors-sample/src/main/res/mipmap-xxhdpi/ic_launcher.png b/scissors-sample/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100755
index 0000000..05ddf02
Binary files /dev/null and b/scissors-sample/src/main/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/scissors-sample/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/scissors-sample/src/main/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100755
index 0000000..c8e7d22
Binary files /dev/null and b/scissors-sample/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/scissors-sample/src/main/res/values-v21/dimens.xml b/scissors-sample/src/main/res/values-v21/dimens.xml
new file mode 100644
index 0000000..d0650d3
--- /dev/null
+++ b/scissors-sample/src/main/res/values-v21/dimens.xml
@@ -0,0 +1,5 @@
+
+
+ 24dp
+ 32dp
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/values-v23/dimens.xml b/scissors-sample/src/main/res/values-v23/dimens.xml
new file mode 100644
index 0000000..fc158ab
--- /dev/null
+++ b/scissors-sample/src/main/res/values-v23/dimens.xml
@@ -0,0 +1,5 @@
+
+
+ 32dp
+ 40dp
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/values/colors.xml b/scissors-sample/src/main/res/values/colors.xml
new file mode 100644
index 0000000..5780d83
--- /dev/null
+++ b/scissors-sample/src/main/res/values/colors.xml
@@ -0,0 +1,5 @@
+
+
+ #ffe91e63
+ #ffc2185b
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/values/dimens.xml b/scissors-sample/src/main/res/values/dimens.xml
new file mode 100644
index 0000000..73998c5
--- /dev/null
+++ b/scissors-sample/src/main/res/values/dimens.xml
@@ -0,0 +1,5 @@
+
+
+ 0dp
+ 8dp
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/values/strings.xml b/scissors-sample/src/main/res/values/strings.xml
new file mode 100644
index 0000000..eadfe9d
--- /dev/null
+++ b/scissors-sample/src/main/res/values/strings.xml
@@ -0,0 +1,4 @@
+
+
+ Scissors Sample
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/values/styles.xml b/scissors-sample/src/main/res/values/styles.xml
new file mode 100644
index 0000000..0420913
--- /dev/null
+++ b/scissors-sample/src/main/res/values/styles.xml
@@ -0,0 +1,10 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/scissors-sample/src/main/res/values/themes.xml b/scissors-sample/src/main/res/values/themes.xml
new file mode 100644
index 0000000..d418020
--- /dev/null
+++ b/scissors-sample/src/main/res/values/themes.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/scissors/build.gradle b/scissors/build.gradle
new file mode 100644
index 0000000..fe6e773
--- /dev/null
+++ b/scissors/build.gradle
@@ -0,0 +1,37 @@
+apply plugin: 'com.android.library'
+
+android {
+ compileSdkVersion rootProject.ext.compileSdkVersion
+ buildToolsVersion rootProject.ext.buildToolsVersion
+
+ defaultConfig {
+ minSdkVersion rootProject.ext.minSdkVersion
+ }
+
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_7
+ targetCompatibility JavaVersion.VERSION_1_7
+ }
+
+ dexOptions {
+ preDexLibraries = !rootProject.ext.ci
+ }
+}
+
+dependencies {
+ // Test
+ testCompile 'junit:junit:' + rootProject.ext.junitVersion
+ testCompile 'org.mockito:mockito-core:' + rootProject.ext.mockitoVersion
+ testCompile 'org.robolectric:robolectric:' + rootProject.ext.robolectricVersion
+ testCompile 'org.assertj:assertj-core:' + rootProject.ext.assertjVersion
+ // Support Annotations
+ compile 'com.android.support:support-annotations:' + rootProject.ext.supportVersion
+ // Optional dependencies for extensions
+ // Picasso
+ provided 'com.squareup.picasso:picasso:[2.4.0, 2.5.2)'
+ // Glide
+ provided 'com.github.bumptech.glide:glide:[3.5.0, 3.6.1)'
+ provided 'com.android.support:support-v4:' + rootProject.ext.supportVersion
+}
+
+apply from: rootProject.file('gradle/gradle-mvn-push.gradle')
\ No newline at end of file
diff --git a/scissors/gradle.properties b/scissors/gradle.properties
new file mode 100644
index 0000000..4888f76
--- /dev/null
+++ b/scissors/gradle.properties
@@ -0,0 +1,3 @@
+POM_ARTIFACT_ID=scissors
+POM_NAME=Scissors Library
+POM_PACKAGING=aar
\ No newline at end of file
diff --git a/scissors/src/main/AndroidManifest.xml b/scissors/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..967a645
--- /dev/null
+++ b/scissors/src/main/AndroidManifest.xml
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/scissors/src/main/java/com/lyft/android/scissors/BitmapLoader.java b/scissors/src/main/java/com/lyft/android/scissors/BitmapLoader.java
new file mode 100644
index 0000000..1b591e3
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/BitmapLoader.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.widget.ImageView;
+
+/**
+ * Load extension delegates actual Bitmap loading to a BitmapLoader allowing it to use different implementations.
+ *
+ * @see PicassoBitmapLoader
+ * @see GlideBitmapLoader
+ */
+public interface BitmapLoader {
+
+ void load(@Nullable Object model, @NonNull ImageView view);
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/CropView.java b/scissors/src/main/java/com/lyft/android/scissors/CropView.java
new file mode 100644
index 0000000..9af0729
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/CropView.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.support.annotation.DrawableRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.widget.ImageView;
+import com.lyft.android.scissors.CropViewExtensions.CropRequest;
+import com.lyft.android.scissors.CropViewExtensions.LoadRequest;
+import java.io.File;
+import java.io.OutputStream;
+
+/**
+ * An {@link ImageView} with a fixed viewport and cropping capabilities.
+ */
+public class CropView extends ImageView {
+
+ private static final int MAX_TOUCH_POINTS = 2;
+ private TouchManager touchManager;
+
+ private Paint viewportPaint = new Paint();
+ private Paint bitmapPaint = new Paint();
+
+ private Bitmap bitmap;
+ private Matrix transform = new Matrix();
+ private Extensions extensions;
+
+ public CropView(Context context) {
+ super(context);
+ initCropView(context, null);
+ }
+
+ public CropView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ initCropView(context, attrs);
+ }
+
+ void initCropView(Context context, AttributeSet attrs) {
+ CropViewConfig config = CropViewConfig.from(context, attrs);
+
+ touchManager = new TouchManager(MAX_TOUCH_POINTS, config);
+
+ bitmapPaint.setFilterBitmap(true);
+ viewportPaint.setColor(config.getViewportHeaderFooterColor());
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ if (bitmap == null) {
+ return;
+ }
+
+ drawBitmap(canvas);
+
+ final int bottom = getBottom();
+ final int viewportWidth = touchManager.getViewportWidth();
+ final int viewportHeight = touchManager.getViewportHeight();
+ final int remainingHalf = (bottom - viewportHeight) / 2;
+ canvas.drawRect(0, 0, viewportWidth, remainingHalf, viewportPaint);
+ canvas.drawRect(0, bottom - remainingHalf, viewportWidth, bottom, viewportPaint);
+ }
+
+ private void drawBitmap(Canvas canvas) {
+ transform.reset();
+ touchManager.applyPositioningAndScale(transform);
+
+ canvas.drawBitmap(bitmap, transform, bitmapPaint);
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ resetTouchManager();
+ }
+
+ @Override
+ public void setImageResource(@DrawableRes int resId) {
+ final Bitmap bitmap = resId > 0
+ ? BitmapFactory.decodeResource(getResources(), resId)
+ : null;
+ setImageBitmap(bitmap);
+ }
+
+ @Override
+ public void setImageDrawable(@Nullable Drawable drawable) {
+ final Bitmap bitmap;
+ if (drawable instanceof BitmapDrawable) {
+ BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
+ bitmap = bitmapDrawable.getBitmap();
+ } else if (drawable != null) {
+ bitmap = Utils.asBitmap(drawable, getWidth(), getHeight());
+ } else {
+ bitmap = null;
+ }
+
+ setImageBitmap(bitmap);
+ }
+
+ @Override
+ public void setImageURI(@Nullable Uri uri) {
+ extensions().load(uri);
+ }
+
+ @Override
+ public void setImageBitmap(@Nullable Bitmap bitmap) {
+ this.bitmap = bitmap;
+ resetTouchManager();
+ invalidate();
+ }
+
+ /**
+ * @return Current working Bitmap or null if none has been set yet.
+ */
+ @Nullable
+ public Bitmap getImageBitmap() {
+ return bitmap;
+ }
+
+ private void resetTouchManager() {
+ final boolean invalidBitmap = bitmap == null;
+ final int bitmapWidth = invalidBitmap ? 0 : bitmap.getWidth();
+ final int bitmapHeight = invalidBitmap ? 0 : bitmap.getHeight();
+ touchManager.resetFor(bitmapWidth, bitmapHeight, getWidth(), getHeight());
+ }
+
+ @Override
+ public boolean dispatchTouchEvent(MotionEvent event) {
+ super.dispatchTouchEvent(event);
+
+ touchManager.onEvent(event);
+ invalidate();
+ return true;
+ }
+
+ /**
+ * Performs synchronous image cropping based on configuration.
+ *
+ * @return A {@link Bitmap} cropped based on viewport and user panning and zooming or null if no {@link Bitmap} has been
+ * provided.
+ */
+ @Nullable
+ public Bitmap crop() {
+ if (bitmap == null) {
+ return null;
+ }
+
+ final Bitmap src = bitmap;
+ final Bitmap.Config srcConfig = src.getConfig();
+ final Bitmap.Config config = srcConfig == null ? Bitmap.Config.ARGB_8888 : srcConfig;
+ final int viewportHeight = touchManager.getViewportHeight();
+ final int viewportWidth = touchManager.getViewportWidth();
+
+ final Bitmap dst = Bitmap.createBitmap(viewportWidth, viewportHeight, config);
+
+ Canvas canvas = new Canvas(dst);
+ final int remainingHalf = (getBottom() - viewportHeight) / 2;
+ canvas.translate(0, -remainingHalf);
+
+ drawBitmap(canvas);
+
+ return dst;
+ }
+
+ /**
+ * Obtain current viewport width.
+ *
+ * @return Current viewport width.
+ * Note: It might be 0 if layout pass has not been completed.
+ */
+ public int getViewportWidth() {
+ return touchManager.getViewportWidth();
+ }
+
+ /**
+ * Obtain current viewport height.
+ *
+ * @return Current viewport height.
+ * Note: It might be 0 if layout pass has not been completed.
+ */
+ public int getViewportHeight() {
+ return touchManager.getViewportHeight();
+ }
+
+ /**
+ * Offers common utility extensions.
+ *
+ * @return Extensions object used to perform chained calls.
+ */
+ public Extensions extensions() {
+ if (extensions == null) {
+ extensions = new Extensions(this);
+ }
+ return extensions;
+ }
+
+ /**
+ * Optional extensions to perform common actions involving a {@link CropView}
+ */
+ public static class Extensions {
+
+ private final CropView cropView;
+
+ Extensions(CropView cropView) {
+ this.cropView = cropView;
+ }
+
+ /**
+ * Load a {@link Bitmap} using an automatically resolved {@link BitmapLoader} which will attempt to scale image to fill view.
+ *
+ * @param model Model used by {@link BitmapLoader} to load desired {@link Bitmap}
+ * @see PicassoBitmapLoader
+ * @see GlideBitmapLoader
+ */
+ public void load(@Nullable Object model) {
+ new LoadRequest(cropView)
+ .load(model);
+ }
+
+ /**
+ * Load a {@link Bitmap} using given {@link BitmapLoader}, you must call {@link LoadRequest#load(Object)} afterwards.
+ *
+ * @param bitmapLoader {@link BitmapLoader} used to load desired {@link Bitmap}
+ * @see PicassoBitmapLoader
+ * @see GlideBitmapLoader
+ */
+ public LoadRequest using(@Nullable BitmapLoader bitmapLoader) {
+ return new LoadRequest(cropView).using(bitmapLoader);
+ }
+
+ /**
+ * Perform an asynchronous crop request.
+ *
+ * @return {@link CropRequest} used to chain a configure cropping request, you must call either one of:
+ *
+ * - {@link CropRequest#into(File)}
+ * - {@link CropRequest#into(OutputStream, boolean)}
+ *
+ */
+ public CropRequest crop() {
+ return new CropRequest(cropView);
+ }
+
+ /**
+ * Perform a pick image request using {@link Activity#startActivityForResult(Intent, int)}.
+ */
+ public void pickUsing(@NonNull Activity activity, int requestCode) {
+ CropViewExtensions.pickUsing(activity, requestCode);
+ }
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/CropViewConfig.java b/scissors/src/main/java/com/lyft/android/scissors/CropViewConfig.java
new file mode 100644
index 0000000..6171e00
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/CropViewConfig.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+
+class CropViewConfig {
+
+ public static final float DEFAULT_VIEWPORT_HEIGHT_RATIO = 1f;
+ public static final float DEFAULT_MAXIMUM_SCALE = 10f;
+ public static final float DEFAULT_MINIMUM_SCALE = 0f;
+ public static final int DEFAULT_IMAGE_QUALITY = 100;
+ public static final int DEFAULT_VIEWPORT_HEADER_FOOTER_COLOR = 0xC8000000; // Black with 200 alpha
+
+ private float viewportHeightRatio = DEFAULT_VIEWPORT_HEIGHT_RATIO;
+ private float maxScale = DEFAULT_MAXIMUM_SCALE;
+ private float minScale = DEFAULT_MINIMUM_SCALE;
+ private int viewportHeaderFooterColor = DEFAULT_VIEWPORT_HEADER_FOOTER_COLOR;
+
+ public int getViewportHeaderFooterColor() {
+ return viewportHeaderFooterColor;
+ }
+
+ void setViewportHeaderFooterColor(int viewportHeaderFooterColor) {
+ this.viewportHeaderFooterColor =
+ viewportHeaderFooterColor <= 0
+ ? DEFAULT_VIEWPORT_HEADER_FOOTER_COLOR
+ : viewportHeaderFooterColor;
+ }
+
+ public float getViewportHeightRatio() {
+ return viewportHeightRatio;
+ }
+
+ void setViewportHeightRatio(float viewportHeightRatio) {
+ this.viewportHeightRatio =
+ viewportHeightRatio <= 0 ? DEFAULT_VIEWPORT_HEIGHT_RATIO : viewportHeightRatio;
+ }
+
+ public float getMaxScale() {
+ return maxScale;
+ }
+
+ void setMaxScale(float maxScale) {
+ this.maxScale = maxScale <= 0 ? DEFAULT_MAXIMUM_SCALE : maxScale;
+ }
+
+ public float getMinScale() {
+ return minScale;
+ }
+
+ void setMinScale(float minScale) {
+ this.minScale = minScale <= 0 ? DEFAULT_MINIMUM_SCALE : minScale;
+ }
+
+ public static CropViewConfig from(Context context, AttributeSet attrs) {
+ final CropViewConfig cropViewConfig = new CropViewConfig();
+
+ if (attrs == null) {
+ return cropViewConfig;
+ }
+
+ TypedArray attributes = context.obtainStyledAttributes(
+ attrs,
+ R.styleable.CropView);
+
+ cropViewConfig.setViewportHeightRatio(
+ attributes.getFloat(R.styleable.CropView_cropviewViewportHeightRatio,
+ CropViewConfig.DEFAULT_VIEWPORT_HEIGHT_RATIO));
+
+ cropViewConfig.setMaxScale(
+ attributes.getFloat(R.styleable.CropView_cropviewMaxScale,
+ CropViewConfig.DEFAULT_MAXIMUM_SCALE));
+
+ cropViewConfig.setMinScale(
+ attributes.getFloat(R.styleable.CropView_cropviewMinScale,
+ CropViewConfig.DEFAULT_MINIMUM_SCALE));
+
+ cropViewConfig.setViewportHeaderFooterColor(
+ attributes.getColor(R.styleable.CropView_cropviewViewportHeaderFooterColor,
+ CropViewConfig.DEFAULT_VIEWPORT_HEADER_FOOTER_COLOR));
+ attributes.recycle();
+
+ return cropViewConfig;
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/CropViewExtensions.java b/scissors/src/main/java/com/lyft/android/scissors/CropViewExtensions.java
new file mode 100644
index 0000000..e3f1b85
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/CropViewExtensions.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import java.io.File;
+import java.io.OutputStream;
+import java.util.concurrent.Future;
+
+class CropViewExtensions {
+
+ static void pickUsing(Activity activity, int requestCode) {
+ Intent intent = new Intent();
+ intent.setType("image/*");
+ intent.setAction(Intent.ACTION_GET_CONTENT);
+ intent.addCategory(Intent.CATEGORY_OPENABLE);
+
+ Intent chooserIntent = Intent.createChooser(intent, null);
+
+ activity.startActivityForResult(
+ chooserIntent,
+ requestCode);
+ }
+
+ public static class LoadRequest {
+
+ private final CropView cropView;
+ private BitmapLoader bitmapLoader;
+
+ LoadRequest(CropView cropView) {
+ Utils.checkNotNull(cropView, "cropView == null");
+ this.cropView = cropView;
+ }
+
+ /**
+ * Load a {@link Bitmap} using given {@link BitmapLoader}, you must call {@link LoadRequest#load(Object)} afterwards.
+ *
+ * @param bitmapLoader {@link BitmapLoader} to use
+ * @return current request for chaining, you should call {@link #load(Object)} afterwards.
+ */
+ public LoadRequest using(@Nullable BitmapLoader bitmapLoader) {
+ this.bitmapLoader = bitmapLoader;
+ return this;
+ }
+
+ /**
+ * Load a {@link Bitmap} using a {@link BitmapLoader} into {@link CropView}
+ *
+ * @param model Model used by {@link BitmapLoader} to load desired {@link Bitmap}
+ */
+ public void load(@Nullable Object model) {
+ if (bitmapLoader == null) {
+ bitmapLoader = resolveBitmapLoader(cropView);
+ }
+
+ bitmapLoader.load(model, cropView);
+ }
+ }
+
+ public static class CropRequest {
+
+ private final CropView cropView;
+ private Bitmap.CompressFormat format = Bitmap.CompressFormat.JPEG;
+ private int quality = CropViewConfig.DEFAULT_IMAGE_QUALITY;
+
+ CropRequest(@NonNull CropView cropView) {
+ Utils.checkNotNull(cropView, "cropView == null");
+ this.cropView = cropView;
+ }
+
+ /**
+ * Compression format to use, defaults to {@link Bitmap.CompressFormat#JPEG}.
+ *
+ * @return current request for chaining.
+ */
+ public CropRequest format(@NonNull Bitmap.CompressFormat format) {
+ Utils.checkNotNull(format, "format == null");
+ this.format = format;
+ return this;
+ }
+
+ /**
+ * Compression quality to use (must be 0..100), defaults to {@value CropViewConfig#DEFAULT_IMAGE_QUALITY}.
+ *
+ * @return current request for chaining.
+ */
+ public CropRequest quality(int quality) {
+ Utils.checkArg(quality >= 0 && quality <= 100, "quality must be 0..100");
+ this.quality = quality;
+ return this;
+ }
+
+ /**
+ * Asynchronously flush cropped bitmap into provided file, creating parent directory if required. This is performed in another
+ * thread.
+ *
+ * @param file Must have permissions to write, will be created if doesn't exist or overwrite if it does.
+ * @return {@link Future} used to cancel or wait for this request.
+ */
+ public Future into(@NonNull File file) {
+ final Bitmap croppedBitmap = cropView.crop();
+ return Utils.flushToFile(croppedBitmap, format, quality, file);
+ }
+
+ /**
+ * Asynchronously flush cropped bitmap into provided stream.
+ *
+ * @param outputStream Stream to write to
+ * @param closeWhenDone wetter or not to close provided stream once flushing is done
+ * @return {@link Future} used to cancel or wait for this request.
+ */
+ public Future into(@NonNull OutputStream outputStream, boolean closeWhenDone) {
+ final Bitmap croppedBitmap = cropView.crop();
+ return Utils.flushToStream(croppedBitmap, format, quality, outputStream, closeWhenDone);
+ }
+ }
+
+ final static boolean HAS_PICASSO = canHasClass("com.squareup.picasso.Picasso");
+ final static boolean HAS_GLIDE = canHasClass("com.bumptech.glide.Glide");
+
+ static BitmapLoader resolveBitmapLoader(CropView cropView) {
+ if (HAS_PICASSO) {
+ return PicassoBitmapLoader.createUsing(cropView);
+ }
+ if (HAS_GLIDE) {
+ return GlideBitmapLoader.createUsing(cropView);
+ }
+ throw new IllegalStateException("You must provide a BitmapLoader.");
+ }
+
+ static boolean canHasClass(String className) {
+ try {
+ Class.forName(className);
+ return true;
+ } catch (ClassNotFoundException e) {
+ }
+ return false;
+ }
+
+ static Rect computeTargetSize(int sourceWidth, int sourceHeight, int viewportWidth, int viewportHeight) {
+
+ if (sourceWidth == viewportWidth && sourceHeight == viewportHeight) {
+ return new Rect(0, 0, viewportWidth, viewportHeight); // Fail fast for when source matches exactly on viewport
+ }
+
+ float scale;
+ if (sourceWidth * viewportHeight > viewportWidth * sourceHeight) {
+ scale = (float) viewportHeight / (float) sourceHeight;
+ } else {
+ scale = (float) viewportWidth / (float) sourceWidth;
+ }
+ final int recommendedWidth = (int) ((sourceWidth * scale) + 0.5f);
+ final int recommendedHeight = (int) ((sourceHeight * scale) + 0.5f);
+ return new Rect(0, 0, recommendedWidth, recommendedHeight);
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/GlideBitmapLoader.java b/scissors/src/main/java/com/lyft/android/scissors/GlideBitmapLoader.java
new file mode 100644
index 0000000..a569e2d
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/GlideBitmapLoader.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.widget.ImageView;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestManager;
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation;
+
+/**
+ * A {@link BitmapLoader} with transformation for {@link Glide} image library.
+ *
+ * @see GlideBitmapLoader#createUsing(CropView)
+ * @see GlideBitmapLoader#createUsing(CropView, RequestManager, BitmapPool)
+ */
+public class GlideBitmapLoader implements BitmapLoader {
+
+ private final RequestManager requestManager;
+ private final BitmapTransformation transformation;
+
+ public GlideBitmapLoader(@NonNull RequestManager requestManager, @NonNull BitmapTransformation transformation) {
+ this.requestManager = requestManager;
+ this.transformation = transformation;
+ }
+
+ @Override
+ public void load(@Nullable Object model, @NonNull ImageView imageView) {
+ requestManager.load(model)
+ .asBitmap()
+ .skipMemoryCache(true)
+ .diskCacheStrategy(DiskCacheStrategy.SOURCE)
+ .transform(transformation)
+ .into(imageView);
+ }
+
+ public static BitmapLoader createUsing(@NonNull CropView cropView) {
+ return createUsing(cropView, Glide.with(cropView.getContext()), Glide.get(cropView.getContext()).getBitmapPool());
+ }
+
+ public static BitmapLoader createUsing(@NonNull CropView cropView, @NonNull RequestManager requestManager,
+ @NonNull BitmapPool bitmapPool) {
+ return new GlideBitmapLoader(requestManager,
+ GlideFillViewportTransformation.createUsing(bitmapPool, cropView.getViewportWidth(), cropView.getViewportHeight()));
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/GlideFillViewportTransformation.java b/scissors/src/main/java/com/lyft/android/scissors/GlideFillViewportTransformation.java
new file mode 100644
index 0000000..558d082
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/GlideFillViewportTransformation.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation;
+
+class GlideFillViewportTransformation extends BitmapTransformation {
+
+ private final int viewportWidth;
+ private final int viewportHeight;
+
+ public GlideFillViewportTransformation(BitmapPool bitmapPool, int viewportWidth, int viewportHeight) {
+ super(bitmapPool);
+ this.viewportWidth = viewportWidth;
+ this.viewportHeight = viewportHeight;
+ }
+
+ @Override
+ protected Bitmap transform(BitmapPool bitmapPool, Bitmap source, int outWidth, int outHeight) {
+ int sourceWidth = source.getWidth();
+ int sourceHeight = source.getHeight();
+
+ Rect target = CropViewExtensions.computeTargetSize(sourceWidth, sourceHeight, viewportWidth, viewportHeight);
+
+ int targetWidth = target.width();
+ int targetHeight = target.height();
+
+ return Bitmap.createScaledBitmap(
+ source,
+ targetWidth,
+ targetHeight,
+ true);
+ }
+
+ @Override
+ public String getId() {
+ return getClass().getName();
+ }
+
+ public static BitmapTransformation createUsing(BitmapPool bitmapPool, int viewportWidth, int viewportHeight) {
+ return new GlideFillViewportTransformation(bitmapPool, viewportWidth, viewportHeight);
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/PicassoBitmapLoader.java b/scissors/src/main/java/com/lyft/android/scissors/PicassoBitmapLoader.java
new file mode 100644
index 0000000..2edcdf6
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/PicassoBitmapLoader.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.net.Uri;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.widget.ImageView;
+import com.squareup.picasso.Picasso;
+import com.squareup.picasso.RequestCreator;
+import com.squareup.picasso.Transformation;
+import java.io.File;
+
+/**
+ * A {@link BitmapLoader} with transformation for {@link Picasso} image library.
+ *
+ * @see PicassoBitmapLoader#createUsing(CropView)
+ * @see PicassoBitmapLoader#createUsing(CropView, Picasso)
+ */
+public class PicassoBitmapLoader implements BitmapLoader {
+
+ private final Picasso picasso;
+ private final Transformation transformation;
+
+ public PicassoBitmapLoader(Picasso picasso, Transformation transformation) {
+ this.picasso = picasso;
+ this.transformation = transformation;
+ }
+
+ @Override
+ public void load(@Nullable Object model, @NonNull ImageView imageView) {
+ final RequestCreator requestCreator;
+
+ if (model instanceof Uri || model == null) {
+ requestCreator = picasso.load((Uri) model);
+ } else if (model instanceof String) {
+ requestCreator = picasso.load((String) model);
+ } else if (model instanceof File) {
+ requestCreator = picasso.load((File) model);
+ } else if (model instanceof Integer) {
+ requestCreator = picasso.load((Integer) model);
+ } else {
+ throw new IllegalArgumentException("Unsupported model " + model);
+ }
+
+ requestCreator
+ .skipMemoryCache()
+ .transform(transformation)
+ .into(imageView);
+ }
+
+ public static BitmapLoader createUsing(CropView cropView) {
+ return createUsing(cropView, Picasso.with(cropView.getContext()));
+ }
+
+ public static BitmapLoader createUsing(CropView cropView, Picasso picasso) {
+ return new PicassoBitmapLoader(picasso,
+ PicassoFillViewportTransformation.createUsing(cropView.getViewportWidth(), cropView.getViewportHeight()));
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/PicassoFillViewportTransformation.java b/scissors/src/main/java/com/lyft/android/scissors/PicassoFillViewportTransformation.java
new file mode 100644
index 0000000..8174c12
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/PicassoFillViewportTransformation.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import com.squareup.picasso.Transformation;
+
+class PicassoFillViewportTransformation implements Transformation {
+
+ private final int viewportWidth;
+ private final int viewportHeight;
+
+ public PicassoFillViewportTransformation(int viewportWidth, int viewportHeight) {
+ this.viewportWidth = viewportWidth;
+ this.viewportHeight = viewportHeight;
+ }
+
+ @Override
+ public Bitmap transform(Bitmap source) {
+ int sourceWidth = source.getWidth();
+ int sourceHeight = source.getHeight();
+
+ Rect target = CropViewExtensions.computeTargetSize(sourceWidth, sourceHeight, viewportWidth, viewportHeight);
+ final Bitmap result = Bitmap.createScaledBitmap(
+ source,
+ target.width(),
+ target.height(),
+ true);
+
+ if (result != source) {
+ source.recycle();
+ }
+
+ return result;
+ }
+
+ @Override
+ public String key() {
+ return viewportWidth + "x" + viewportHeight;
+ }
+
+ public static Transformation createUsing(int viewportWidth, int viewportHeight) {
+ return new PicassoFillViewportTransformation(viewportWidth, viewportHeight);
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/TouchManager.java b/scissors/src/main/java/com/lyft/android/scissors/TouchManager.java
new file mode 100644
index 0000000..2feecd8
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/TouchManager.java
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.annotation.TargetApi;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.os.Build;
+import android.view.MotionEvent;
+
+class TouchManager {
+
+ private final int maxNumberOfTouchPoints;
+ private final CropViewConfig cropViewConfig;
+
+ private final TouchPoint[] points;
+ private final TouchPoint[] previousPoints;
+
+ private float minimumScale;
+ private float maximumScale;
+ private Rect imageBounds;
+ private int viewportWidth;
+ private int viewportHeight;
+ private int bitmapWidth;
+ private int bitmapHeight;
+
+ private int verticalLimit;
+ private int horizontalLimit;
+
+ private float scale = 1.0f;
+ private TouchPoint position = new TouchPoint();
+
+ public TouchManager(final int maxNumberOfTouchPoints, final CropViewConfig cropViewConfig) {
+ this.maxNumberOfTouchPoints = maxNumberOfTouchPoints;
+ this.cropViewConfig = cropViewConfig;
+
+ points = new TouchPoint[maxNumberOfTouchPoints];
+ previousPoints = new TouchPoint[maxNumberOfTouchPoints];
+ minimumScale = cropViewConfig.getMinScale();
+ maximumScale = cropViewConfig.getMaxScale();
+ }
+
+ @TargetApi(Build.VERSION_CODES.FROYO)
+ public void onEvent(MotionEvent event) {
+ int index = event.getActionIndex();
+ if (index >= maxNumberOfTouchPoints) {
+ return; // We don't care about this pointer, ignore it.
+ }
+
+ if (isUpAction(event.getActionMasked())) {
+ previousPoints[index] = null;
+ points[index] = null;
+ } else {
+ updateCurrentAndPreviousPoints(event);
+ }
+
+ handleDragGesture();
+ handlePinchGesture();
+ handleDragOutsideViewport(event);
+ }
+
+ public void applyPositioningAndScale(Matrix matrix) {
+ matrix.postTranslate(-bitmapWidth / 2.0f, -bitmapHeight / 2.0f);
+ matrix.postScale(scale, scale);
+ matrix.postTranslate(position.getX(), position.getY());
+ }
+
+ public void resetFor(int bitmapWidth, int bitmapHeight, int availableWidth, int availableHeight) {
+ position.set(availableWidth / 2, availableHeight / 2);
+
+ imageBounds = new Rect(0, 0, availableWidth / 2, availableHeight / 2);
+ setViewport(availableWidth);
+ setMinimumScale();
+
+ this.bitmapWidth = bitmapWidth;
+ this.bitmapHeight = bitmapHeight;
+
+ horizontalLimit = computeLimit(bitmapWidth, viewportWidth);
+ verticalLimit = computeLimit(bitmapHeight, viewportHeight);
+ }
+
+ public int getViewportWidth() {
+ return viewportWidth;
+ }
+
+ public int getViewportHeight() {
+ return viewportHeight;
+ }
+
+ private void handleDragGesture() {
+ if (getDownCount() != 1) {
+ return;
+ }
+ position.add(moveDelta(0));
+ }
+
+ private void handlePinchGesture() {
+ if (getDownCount() != 2) {
+ return;
+ }
+ updateScale();
+ horizontalLimit = computeLimit((int) (bitmapWidth * scale), viewportWidth);
+ verticalLimit = computeLimit((int) (bitmapHeight * scale), viewportHeight);
+ }
+
+ @TargetApi(Build.VERSION_CODES.FROYO)
+ private void handleDragOutsideViewport(MotionEvent event) {
+ if (imageBounds == null || !isUpAction(event.getActionMasked())) {
+ return;
+ }
+
+ float newY = position.getY();
+ int bottom = imageBounds.bottom;
+
+ if (bottom - newY >= verticalLimit) {
+ newY = bottom - verticalLimit;
+ } else if (newY - bottom >= verticalLimit) {
+ newY = bottom + verticalLimit;
+ }
+
+ float newX = position.getX();
+ int right = imageBounds.right;
+ if (newX <= right - horizontalLimit) {
+ newX = right - horizontalLimit;
+ } else if (newX > right + horizontalLimit) {
+ newX = right + horizontalLimit;
+ }
+
+ position.set(newX, newY);
+ }
+
+ private void updateCurrentAndPreviousPoints(MotionEvent event) {
+ for (int i = 0; i < maxNumberOfTouchPoints; i++) {
+ if (i < event.getPointerCount()) {
+ final float eventX = event.getX(i);
+ final float eventY = event.getY(i);
+
+ if (points[i] == null) {
+ points[i] = new TouchPoint(eventX, eventY);
+ previousPoints[i] = null;
+ } else {
+ if (previousPoints[i] == null) {
+ previousPoints[i] = new TouchPoint();
+ }
+ previousPoints[i].copy(points[i]);
+ points[i].set(eventX, eventY);
+ }
+ } else {
+ previousPoints[i] = null;
+ points[i] = null;
+ }
+ }
+ }
+
+ private void setViewport(int w) {
+ viewportWidth = w;
+ viewportHeight = (int) (w * cropViewConfig.getViewportHeightRatio());
+ }
+
+ private void setMinimumScale() {
+ float imageAspect = (float) bitmapWidth / bitmapHeight;
+ float viewportAspect = (float) viewportWidth / viewportHeight;
+
+ if (bitmapWidth < viewportWidth || bitmapHeight < viewportHeight) {
+ minimumScale = 1f;
+ } else if (imageAspect > viewportAspect) {
+ minimumScale = (float) viewportHeight / bitmapHeight;
+ } else {
+ minimumScale = (float) viewportWidth / bitmapWidth;
+ }
+ scale = minimumScale;
+ }
+
+ private void updateScale() {
+ TouchPoint current = vector(points[0], points[1]);
+ TouchPoint previous = previousVector(0, 1);
+ float currentDistance = current.getLength();
+ float previousDistance = previous.getLength();
+
+ float newScale = scale;
+ if (previousDistance != 0) {
+ newScale *= currentDistance / previousDistance;
+ }
+ newScale = newScale < minimumScale ? minimumScale : newScale;
+ newScale = newScale > maximumScale ? maximumScale : newScale;
+
+ scale = newScale;
+ }
+
+ private boolean isPressed(int index) {
+ return points[index] != null;
+ }
+
+ private int getDownCount() {
+ int count = 0;
+ for (TouchPoint point : points) {
+ if (point != null) {
+ count++;
+ }
+ }
+ return count;
+ }
+
+ private TouchPoint moveDelta(int index) {
+ if (isPressed(index)) {
+ TouchPoint previous =
+ previousPoints[index] != null ? previousPoints[index] : points[index];
+ return TouchPoint.subtract(points[index], previous);
+ } else {
+ return new TouchPoint();
+ }
+ }
+
+ private TouchPoint previousVector(int indexA, int indexB) {
+ return previousPoints[indexA] == null || previousPoints[indexB] == null
+ ? vector(points[indexA], points[indexB])
+ : vector(previousPoints[indexA], previousPoints[indexB]);
+ }
+
+ private static int computeLimit
+ (int bitmapSize, int viewportSize) {
+ return (bitmapSize - viewportSize) / 2;
+ }
+
+ private static TouchPoint vector(TouchPoint a, TouchPoint b) {
+ return TouchPoint.subtract(b, a);
+ }
+
+ private static boolean isUpAction(int actionMasked) {
+ return actionMasked == MotionEvent.ACTION_POINTER_UP || actionMasked == MotionEvent.ACTION_UP;
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/TouchPoint.java b/scissors/src/main/java/com/lyft/android/scissors/TouchPoint.java
new file mode 100644
index 0000000..8dc089a
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/TouchPoint.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+class TouchPoint {
+
+ private float x;
+ private float y;
+
+ public TouchPoint() {
+ }
+
+ public TouchPoint(float x, float y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ public float getX() {
+ return x;
+ }
+
+ public float getY() {
+ return y;
+ }
+
+ public float getLength() {
+ return (float) Math.sqrt(x * x + y * y);
+ }
+
+ public TouchPoint copy(TouchPoint other) {
+ x = other.getX();
+ y = other.getY();
+ return this;
+ }
+
+ public TouchPoint set(float x, float y) {
+ this.x = x;
+ this.y = y;
+ return this;
+ }
+
+ public TouchPoint add(TouchPoint value) {
+ this.x += value.getX();
+ this.y += value.getY();
+ return this;
+ }
+
+ public static TouchPoint subtract(TouchPoint lhs, TouchPoint rhs) {
+ return new TouchPoint(lhs.x - rhs.x, lhs.y - rhs.y);
+ }
+
+ @Override
+ public String toString() {
+ return String.format("(%.4f, %.4f)", x, y);
+ }
+}
diff --git a/scissors/src/main/java/com/lyft/android/scissors/Utils.java b/scissors/src/main/java/com/lyft/android/scissors/Utils.java
new file mode 100644
index 0000000..78a623f
--- /dev/null
+++ b/scissors/src/main/java/com/lyft/android/scissors/Utils.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2015 Lyft, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.lyft.android.scissors;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+class Utils {
+
+ public static void checkArg(boolean expression, String msg) {
+ if (!expression) {
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ public static void checkNotNull(Object object, String msg) {
+ if (object == null) {
+ throw new NullPointerException(msg);
+ }
+ }
+
+ public static Bitmap asBitmap(Drawable drawable, int minWidth, int minHeight) {
+ final Rect tmpRect = new Rect();
+ drawable.copyBounds(tmpRect);
+ if (tmpRect.isEmpty()) {
+ tmpRect.set(0, 0, Math.max(minWidth, drawable.getIntrinsicWidth()), Math.max(minHeight, drawable.getIntrinsicHeight()));
+ drawable.setBounds(tmpRect);
+ }
+ Bitmap bitmap = Bitmap.createBitmap(tmpRect.width(), tmpRect.height(), Bitmap.Config.ARGB_8888);
+ drawable.draw(new Canvas(bitmap));
+ return bitmap;
+ }
+
+ private final static ExecutorService EXECUTOR_SERVICE = Executors.newCachedThreadPool();
+ private static final String TAG = "scissors.Utils";
+
+ public static Future flushToFile(final Bitmap bitmap,
+ final Bitmap.CompressFormat format,
+ final int quality,
+ final File file) {
+
+ return EXECUTOR_SERVICE.submit(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ file.getParentFile().mkdirs();
+
+ OutputStream outputStream = new FileOutputStream(file);
+ bitmap.compress(format, quality, outputStream);
+ outputStream.flush();
+ outputStream.close();
+ } catch (final Throwable throwable) {
+ if (BuildConfig.DEBUG) {
+ Log.e(TAG, "Error attempting to save bitmap.", throwable);
+ }
+ }
+ }
+ }, null);
+ }
+
+ public static Future flushToStream(final Bitmap bitmap,
+ final Bitmap.CompressFormat format,
+ final int quality,
+ final OutputStream outputStream,
+ final boolean closeWhenDone) {
+
+ return EXECUTOR_SERVICE.submit(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ bitmap.compress(format, quality, outputStream);
+ outputStream.flush();
+ if (closeWhenDone) {
+ outputStream.close();
+ }
+ } catch (final Throwable throwable) {
+ if (BuildConfig.DEBUG) {
+ Log.e(TAG, "Error attempting to save bitmap.", throwable);
+ }
+ }
+ }
+ }, null);
+ }
+}
diff --git a/scissors/src/main/res/drawable-hdpi/ic_content_add.png b/scissors/src/main/res/drawable-hdpi/ic_content_add.png
new file mode 100755
index 0000000..3855989
Binary files /dev/null and b/scissors/src/main/res/drawable-hdpi/ic_content_add.png differ
diff --git a/scissors/src/main/res/drawable-hdpi/ic_content_content_cut.png b/scissors/src/main/res/drawable-hdpi/ic_content_content_cut.png
new file mode 100755
index 0000000..4ab8515
Binary files /dev/null and b/scissors/src/main/res/drawable-hdpi/ic_content_content_cut.png differ
diff --git a/scissors/src/main/res/drawable-mdpi/ic_content_add.png b/scissors/src/main/res/drawable-mdpi/ic_content_add.png
new file mode 100755
index 0000000..2fd396f
Binary files /dev/null and b/scissors/src/main/res/drawable-mdpi/ic_content_add.png differ
diff --git a/scissors/src/main/res/drawable-mdpi/ic_content_content_cut.png b/scissors/src/main/res/drawable-mdpi/ic_content_content_cut.png
new file mode 100755
index 0000000..7acc8f2
Binary files /dev/null and b/scissors/src/main/res/drawable-mdpi/ic_content_content_cut.png differ
diff --git a/scissors/src/main/res/drawable-xhdpi/ic_content_add.png b/scissors/src/main/res/drawable-xhdpi/ic_content_add.png
new file mode 100755
index 0000000..478cb6e
Binary files /dev/null and b/scissors/src/main/res/drawable-xhdpi/ic_content_add.png differ
diff --git a/scissors/src/main/res/drawable-xhdpi/ic_content_content_cut.png b/scissors/src/main/res/drawable-xhdpi/ic_content_content_cut.png
new file mode 100755
index 0000000..0cc6ded
Binary files /dev/null and b/scissors/src/main/res/drawable-xhdpi/ic_content_content_cut.png differ
diff --git a/scissors/src/main/res/drawable-xxhdpi/ic_content_add.png b/scissors/src/main/res/drawable-xxhdpi/ic_content_add.png
new file mode 100755
index 0000000..f976d7e
Binary files /dev/null and b/scissors/src/main/res/drawable-xxhdpi/ic_content_add.png differ
diff --git a/scissors/src/main/res/drawable-xxhdpi/ic_content_content_cut.png b/scissors/src/main/res/drawable-xxhdpi/ic_content_content_cut.png
new file mode 100755
index 0000000..8da18d5
Binary files /dev/null and b/scissors/src/main/res/drawable-xxhdpi/ic_content_content_cut.png differ
diff --git a/scissors/src/main/res/drawable-xxxhdpi/ic_content_add.png b/scissors/src/main/res/drawable-xxxhdpi/ic_content_add.png
new file mode 100755
index 0000000..512f8f3
Binary files /dev/null and b/scissors/src/main/res/drawable-xxxhdpi/ic_content_add.png differ
diff --git a/scissors/src/main/res/drawable-xxxhdpi/ic_content_content_cut.png b/scissors/src/main/res/drawable-xxxhdpi/ic_content_content_cut.png
new file mode 100755
index 0000000..c23e9ef
Binary files /dev/null and b/scissors/src/main/res/drawable-xxxhdpi/ic_content_content_cut.png differ
diff --git a/scissors/src/main/res/values/attrs.xml b/scissors/src/main/res/values/attrs.xml
new file mode 100644
index 0000000..82024e2
--- /dev/null
+++ b/scissors/src/main/res/values/attrs.xml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/scissors/src/test/java/com/lyft/android/scissors/TargetSizeTest.java b/scissors/src/test/java/com/lyft/android/scissors/TargetSizeTest.java
new file mode 100644
index 0000000..5e128b8
--- /dev/null
+++ b/scissors/src/test/java/com/lyft/android/scissors/TargetSizeTest.java
@@ -0,0 +1,99 @@
+package com.lyft.android.scissors;
+
+import android.graphics.Rect;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.ParameterizedRobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+@RunWith(ParameterizedRobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class TargetSizeTest {
+
+ @ParameterizedRobolectricTestRunner.Parameters(name = "{2} viewport = [{0}x{1}]")
+ public static Collection data() {
+ return Arrays.asList(new Object[][] {
+ { 100, 100, SQUARED },
+ { 100, 56, LANDSCAPE },
+ { 56, 100, PORTRAIT }
+ });
+ }
+
+ final Rect viewport;
+ final String orientation;
+
+ public TargetSizeTest(int viewportW, int viewportH, String orientation) {
+ this.viewport = new Rect(0, 0, viewportW, viewportH);
+ this.orientation = orientation;
+ }
+
+ @Test
+ public void targetFitsViewport() {
+ final int sourceW = viewport.width();
+ final int sourceH = viewport.height();
+
+ Rect target = CropViewExtensions.computeTargetSize(sourceW, sourceH, viewport.width(), viewport.height());
+
+ assertThat(target.width()).isEqualTo(viewport.width());
+ assertThat(target.height()).isEqualTo(viewport.height());
+ }
+
+ @Test
+ public void targetScalesUpToViewport() {
+ final int sourceW = viewport.width() - 11;
+ final int sourceH = viewport.height() - 11;
+
+ Rect target = CropViewExtensions.computeTargetSize(sourceW, sourceH, viewport.width(), viewport.height());
+
+ switch (orientation) {
+ case LANDSCAPE:
+ assertThat(target.width()).isGreaterThan(viewport.width());
+ assertThat(target.height()).isEqualTo(viewport.height());
+ break;
+ case PORTRAIT:
+ assertThat(target.width()).isEqualTo(viewport.width());
+ assertThat(target.height()).isGreaterThan(viewport.height());
+ break;
+ case SQUARED:
+ assertThat(target.width()).isEqualTo(viewport.width());
+ assertThat(target.height()).isEqualTo(viewport.height());
+ break;
+ default:
+ fail("Unexpected orientation " + orientation);
+ }
+ }
+
+ @Test
+ public void targetScalesDownIfBiggerThanViewport() {
+ final int sourceW = viewport.width() + 101;
+ final int sourceH = viewport.height() + 101;
+
+ Rect target = CropViewExtensions.computeTargetSize(sourceW, sourceH, viewport.width(), viewport.height());
+
+ switch (orientation) {
+ case LANDSCAPE:
+ assertThat(target.width()).isEqualTo(viewport.width());
+ assertThat(target.height()).isGreaterThan(viewport.height());
+ break;
+ case PORTRAIT:
+ assertThat(target.width()).isGreaterThan(viewport.width());
+ assertThat(target.height()).isEqualTo(viewport.height());
+ break;
+ case SQUARED:
+ assertThat(target.width()).isEqualTo(viewport.width());
+ assertThat(target.height()).isEqualTo(viewport.height());
+ break;
+ default:
+ fail("Unexpected orientation " + orientation);
+ }
+ }
+
+ static final String SQUARED = "Squared";
+ static final String LANDSCAPE = "Landscape";
+ static final String PORTRAIT = "Portrait";
+}
\ No newline at end of file
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..2239eb0
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1 @@
+include 'scissors', 'scissors-sample'
+
+Scissors
+=========================
+
+Fixed viewport image cropping library for Android with built-in support for [Picasso][picasso] or [Glide][glide].
+
+Usage
+-----
+
+See `scissors-sample`.
+
+
+
+
+- Include it on your layout:
+```xml
+