diff options
Diffstat (limited to 'mobile/android/thirdparty/com/squareup/picasso/Request.java')
| -rw-r--r-- | mobile/android/thirdparty/com/squareup/picasso/Request.java | 307 |
1 files changed, 307 insertions, 0 deletions
diff --git a/mobile/android/thirdparty/com/squareup/picasso/Request.java b/mobile/android/thirdparty/com/squareup/picasso/Request.java new file mode 100644 index 000000000..8e9c32460 --- /dev/null +++ b/mobile/android/thirdparty/com/squareup/picasso/Request.java @@ -0,0 +1,307 @@ +/* + * Copyright (C) 2013 Square, 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.squareup.picasso; + +import android.net.Uri; +import java.util.ArrayList; +import java.util.List; + +import static java.util.Collections.unmodifiableList; + +/** Immutable data about an image and the transformations that will be applied to it. */ +public final class Request { + /** + * The image URI. + * <p> + * This is mutually exclusive with {@link #resourceId}. + */ + public final Uri uri; + /** + * The image resource ID. + * <p> + * This is mutually exclusive with {@link #uri}. + */ + public final int resourceId; + /** List of custom transformations to be applied after the built-in transformations. */ + public final List<Transformation> transformations; + /** Target image width for resizing. */ + public final int targetWidth; + /** Target image height for resizing. */ + public final int targetHeight; + /** + * True if the final image should use the 'centerCrop' scale technique. + * <p> + * This is mutually exclusive with {@link #centerInside}. + */ + public final boolean centerCrop; + /** + * True if the final image should use the 'centerInside' scale technique. + * <p> + * This is mutually exclusive with {@link #centerCrop}. + */ + public final boolean centerInside; + /** Amount to rotate the image in degrees. */ + public final float rotationDegrees; + /** Rotation pivot on the X axis. */ + public final float rotationPivotX; + /** Rotation pivot on the Y axis. */ + public final float rotationPivotY; + /** Whether or not {@link #rotationPivotX} and {@link #rotationPivotY} are set. */ + public final boolean hasRotationPivot; + + private Request(Uri uri, int resourceId, List<Transformation> transformations, int targetWidth, + int targetHeight, boolean centerCrop, boolean centerInside, float rotationDegrees, + float rotationPivotX, float rotationPivotY, boolean hasRotationPivot) { + this.uri = uri; + this.resourceId = resourceId; + if (transformations == null) { + this.transformations = null; + } else { + this.transformations = unmodifiableList(transformations); + } + this.targetWidth = targetWidth; + this.targetHeight = targetHeight; + this.centerCrop = centerCrop; + this.centerInside = centerInside; + this.rotationDegrees = rotationDegrees; + this.rotationPivotX = rotationPivotX; + this.rotationPivotY = rotationPivotY; + this.hasRotationPivot = hasRotationPivot; + } + + String getName() { + if (uri != null) { + return uri.getPath(); + } + return Integer.toHexString(resourceId); + } + + public boolean hasSize() { + return targetWidth != 0; + } + + boolean needsTransformation() { + return needsMatrixTransform() || hasCustomTransformations(); + } + + boolean needsMatrixTransform() { + return targetWidth != 0 || rotationDegrees != 0; + } + + boolean hasCustomTransformations() { + return transformations != null; + } + + public Builder buildUpon() { + return new Builder(this); + } + + /** Builder for creating {@link Request} instances. */ + public static final class Builder { + private Uri uri; + private int resourceId; + private int targetWidth; + private int targetHeight; + private boolean centerCrop; + private boolean centerInside; + private float rotationDegrees; + private float rotationPivotX; + private float rotationPivotY; + private boolean hasRotationPivot; + private List<Transformation> transformations; + + /** Start building a request using the specified {@link Uri}. */ + public Builder(Uri uri) { + setUri(uri); + } + + /** Start building a request using the specified resource ID. */ + public Builder(int resourceId) { + setResourceId(resourceId); + } + + Builder(Uri uri, int resourceId) { + this.uri = uri; + this.resourceId = resourceId; + } + + private Builder(Request request) { + uri = request.uri; + resourceId = request.resourceId; + targetWidth = request.targetWidth; + targetHeight = request.targetHeight; + centerCrop = request.centerCrop; + centerInside = request.centerInside; + rotationDegrees = request.rotationDegrees; + rotationPivotX = request.rotationPivotX; + rotationPivotY = request.rotationPivotY; + hasRotationPivot = request.hasRotationPivot; + if (request.transformations != null) { + transformations = new ArrayList<Transformation>(request.transformations); + } + } + + boolean hasImage() { + return uri != null || resourceId != 0; + } + + boolean hasSize() { + return targetWidth != 0; + } + + /** + * Set the target image Uri. + * <p> + * This will clear an image resource ID if one is set. + */ + public Builder setUri(Uri uri) { + if (uri == null) { + throw new IllegalArgumentException("Image URI may not be null."); + } + this.uri = uri; + this.resourceId = 0; + return this; + } + + /** + * Set the target image resource ID. + * <p> + * This will clear an image Uri if one is set. + */ + public Builder setResourceId(int resourceId) { + if (resourceId == 0) { + throw new IllegalArgumentException("Image resource ID may not be 0."); + } + this.resourceId = resourceId; + this.uri = null; + return this; + } + + /** Resize the image to the specified size in pixels. */ + public Builder resize(int targetWidth, int targetHeight) { + if (targetWidth <= 0) { + throw new IllegalArgumentException("Width must be positive number."); + } + if (targetHeight <= 0) { + throw new IllegalArgumentException("Height must be positive number."); + } + this.targetWidth = targetWidth; + this.targetHeight = targetHeight; + return this; + } + + /** Clear the resize transformation, if any. This will also clear center crop/inside if set. */ + public Builder clearResize() { + targetWidth = 0; + targetHeight = 0; + centerCrop = false; + centerInside = false; + return this; + } + + /** + * Crops an image inside of the bounds specified by {@link #resize(int, int)} rather than + * distorting the aspect ratio. This cropping technique scales the image so that it fills the + * requested bounds and then crops the extra. + */ + public Builder centerCrop() { + if (centerInside) { + throw new IllegalStateException("Center crop can not be used after calling centerInside"); + } + centerCrop = true; + return this; + } + + /** Clear the center crop transformation flag, if set. */ + public Builder clearCenterCrop() { + centerCrop = false; + return this; + } + + /** + * Centers an image inside of the bounds specified by {@link #resize(int, int)}. This scales + * the image so that both dimensions are equal to or less than the requested bounds. + */ + public Builder centerInside() { + if (centerCrop) { + throw new IllegalStateException("Center inside can not be used after calling centerCrop"); + } + centerInside = true; + return this; + } + + /** Clear the center inside transformation flag, if set. */ + public Builder clearCenterInside() { + centerInside = false; + return this; + } + + /** Rotate the image by the specified degrees. */ + public Builder rotate(float degrees) { + rotationDegrees = degrees; + return this; + } + + /** Rotate the image by the specified degrees around a pivot point. */ + public Builder rotate(float degrees, float pivotX, float pivotY) { + rotationDegrees = degrees; + rotationPivotX = pivotX; + rotationPivotY = pivotY; + hasRotationPivot = true; + return this; + } + + /** Clear the rotation transformation, if any. */ + public Builder clearRotation() { + rotationDegrees = 0; + rotationPivotX = 0; + rotationPivotY = 0; + hasRotationPivot = false; + return this; + } + + /** + * Add a custom transformation to be applied to the image. + * <p/> + * Custom transformations will always be run after the built-in transformations. + */ + public Builder transform(Transformation transformation) { + if (transformation == null) { + throw new IllegalArgumentException("Transformation must not be null."); + } + if (transformations == null) { + transformations = new ArrayList<Transformation>(2); + } + transformations.add(transformation); + return this; + } + + /** Create the immutable {@link Request} object. */ + public Request build() { + if (centerInside && centerCrop) { + throw new IllegalStateException("Center crop and center inside can not be used together."); + } + if (centerCrop && targetWidth == 0) { + throw new IllegalStateException("Center crop requires calling resize."); + } + if (centerInside && targetWidth == 0) { + throw new IllegalStateException("Center inside requires calling resize."); + } + return new Request(uri, resourceId, transformations, targetWidth, targetHeight, centerCrop, + centerInside, rotationDegrees, rotationPivotX, rotationPivotY, hasRotationPivot); + } + } +} |