Base Configuration

ExternalLibs/Parse-SDK-Android/Parse/src/main/java/com/parse/ParsePolygon.java

@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2015-present, Parse, LLC.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+package com.parse;
+
+import android.location.Criteria;
+import android.location.Location;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import java.util.Locale;
+import java.util.List;
+
+import bolts.Continuation;
+import bolts.Task;
+
+/**
+ * {@code ParsePolygon} represents a set of coordinates that may be associated with a key
+ * in a {@link ParseObject} or used as a reference point for geo queries. This allows proximity
+ * based queries on the key.
+ *
+ * Example:
+ * <pre>
+ * List<ParseGeoPoint> points = new ArrayList<ParseGeoPoint>();
+ * points.add(new ParseGeoPoint(0,0));
+ * points.add(new ParseGeoPoint(0,1));
+ * points.add(new ParseGeoPoint(1,1));
+ * points.add(new ParseGeoPoint(1,0));
+ * ParsePolygon polygon = new ParsePolygon(points);
+ * ParseObject object = new ParseObject("PlaceObject");
+ * object.put("area", polygon);
+ * object.save();
+ * </pre>
+ */
+
+public class ParsePolygon implements Parcelable {
+
+  private List<ParseGeoPoint> coordinates;
+
+  /**
+   * Creates a new polygon with the specified {@link ParseGeoPoint}.
+   *
+   * @param coords
+   *          The polygon's coordinates.
+   */
+  public ParsePolygon(List<ParseGeoPoint> coords) {
+    setCoordinates(coords);
+  }
+
+  /**
+   * Creates a copy of {@code polygon};
+   *
+   * @param polygon
+   *          The polygon to copy.
+   */
+  public ParsePolygon(ParsePolygon polygon) {
+    this(polygon.getCoordinates());
+  }
+
+  /**
+   * Creates a new point instance from a {@link Parcel} source. This is used when unparceling a
+   * ParsePolygon. Subclasses that need Parcelable behavior should provide their own
+   * {@link android.os.Parcelable.Creator} and override this constructor.
+   *
+   * @param source The recovered parcel.
+   */
+  protected ParsePolygon(Parcel source) {
+    this(source, ParseParcelDecoder.get());
+  }
+
+  /**
+   * Creates a new point instance from a {@link Parcel} using the given {@link ParseParcelDecoder}.
+   * The decoder is currently unused, but it might be in the future, plus this is the pattern we
+   * are using in parcelable classes.
+   *
+   * @param source the parcel
+   * @param decoder the decoder
+   */
+  ParsePolygon(Parcel source, ParseParcelDecoder decoder) {
+    setCoordinates(source.readArrayList(null));
+  }
+
+
+  /**
+   * Set coordinates. Valid are Array of GeoPoint, ParseGeoPoint or Location
+   * at least 3 points
+   *
+   * @param coords
+   *          The polygon's coordinates.
+   */
+  public void setCoordinates(List<ParseGeoPoint> coords) {
+    this.coordinates = ParsePolygon.validate(coords);
+  }
+
+  /**
+   * Get coordinates.
+   */
+  public List<ParseGeoPoint> getCoordinates() {
+    return coordinates;
+  }
+
+  /**
+   * Get converts coordinate to JSONArray.
+   */
+  protected JSONArray coordinatesToJSONArray() throws JSONException{
+    JSONArray points = new JSONArray();
+    for (ParseGeoPoint coordinate : coordinates) {
+      JSONArray point = new JSONArray();
+      point.put(coordinate.getLatitude());
+      point.put(coordinate.getLongitude());
+      points.put(point);
+    }
+    return points;
+  }
+
+  /**
+   * Checks if this {@code ParsePolygon}; contains {@link ParseGeoPoint}.
+   */
+  public boolean containsPoint(ParseGeoPoint point) {
+    double minX = coordinates.get(0).getLatitude();
+    double maxX = coordinates.get(0).getLatitude();
+    double minY = coordinates.get(0).getLongitude();
+    double maxY = coordinates.get(0).getLongitude();
+
+    for ( int i = 1; i < coordinates.size(); i += 1) {
+        ParseGeoPoint geoPoint = coordinates.get(i);
+        minX = Math.min(geoPoint.getLatitude(), minX);
+        maxX = Math.max(geoPoint.getLatitude(), maxX);
+        minY = Math.min(geoPoint.getLongitude(), minY);
+        maxY = Math.max(geoPoint.getLongitude(), maxY);
+    }
+
+    boolean outside = point.getLatitude() < minX || point.getLatitude() > maxX || point.getLongitude() < minY || point.getLongitude() > maxY;
+    if (outside) {
+        return false;
+    }
+
+    boolean inside = false;
+    for (int i = 0, j = coordinates.size() - 1 ; i < coordinates.size(); j = i++) {
+      double startX = coordinates.get(i).getLatitude();
+      double startY = coordinates.get(i).getLongitude();
+      double endX = coordinates.get(j).getLatitude();
+      double endY = coordinates.get(j).getLongitude();
+
+      boolean intersect = (( startY > point.getLongitude() ) != ( endY > point.getLongitude() ) &&
+          point.getLatitude() < ( endX - startX ) * ( point.getLongitude() - startY ) / ( endY - startY ) + startX);
+
+        if (intersect) {
+            inside = !inside;
+        }
+    }
+    return inside;
+  }
+
+  /**
+   * Throws exception for invalid coordinates.
+   */
+  static List<ParseGeoPoint> validate(List<ParseGeoPoint> coords) {
+    if (coords.size() < 3) {
+      throw new IllegalArgumentException("Polygon must have at least 3 GeoPoints");
+    }
+    return coords;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj == null || !(obj instanceof ParsePolygon)) {
+      return false;
+    }
+    if (obj == this) {
+      return true;
+    }
+    ParsePolygon other = (ParsePolygon) obj;
+
+    if (coordinates.size() != other.getCoordinates().size()) {
+      return false;
+    }
+
+    boolean isEqual = true;
+    for (int i = 0; i < coordinates.size(); i += 1) {
+      if (coordinates.get(i).getLatitude() != other.getCoordinates().get(i).getLatitude() ||
+          coordinates.get(i).getLongitude() != other.getCoordinates().get(i).getLongitude()) {
+        isEqual = false;
+        break;
+      }
+    }
+    return isEqual;
+  }
+
+  @Override
+  public String toString() {
+    return String.format(Locale.US, "ParsePolygon: %s", coordinates);
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    writeToParcel(dest, ParseParcelEncoder.get());
+  }
+
+  void writeToParcel(Parcel dest, ParseParcelEncoder encoder) {
+    dest.writeList(coordinates);
+  }
+
+  public final static Creator<ParsePolygon> CREATOR = new Creator<ParsePolygon>() {
+    @Override
+    public ParsePolygon createFromParcel(Parcel source) {
+      return new ParsePolygon(source, ParseParcelDecoder.get());
+    }
+
+    @Override
+    public ParsePolygon[] newArray(int size) {
+      return new ParsePolygon[size];
+    }
+  };
+}