react-native-gizwits-baidu-map 1.0.72

package/android/src/main/java/com/baidu/mapapi/clusterutil/clustering/ClusterManager.java

@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2015 Baidu, Inc. All Rights Reserved.
+ */
+
+package com.baidu.mapapi.clusterutil.clustering;
+
+import android.content.Context;
+import android.os.AsyncTask;
+import android.os.Build;
+
+import com.baidu.mapapi.clusterutil.MarkerManager;
+import com.baidu.mapapi.clusterutil.clustering.algo.Algorithm;
+import com.baidu.mapapi.clusterutil.clustering.algo.NonHierarchicalDistanceBasedAlgorithm;
+import com.baidu.mapapi.clusterutil.clustering.algo.PreCachingAlgorithmDecorator;
+import com.baidu.mapapi.clusterutil.clustering.view.ClusterRenderer;
+import com.baidu.mapapi.clusterutil.clustering.view.DefaultClusterRenderer;
+import com.baidu.mapapi.map.BaiduMap;
+import com.baidu.mapapi.map.MapStatus;
+import com.baidu.mapapi.map.Marker;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * Groups many items on a map based on zoom level.
+ * <p/>
+ * ClusterManager should be added to the map
+ * <li>
+ */
+public class ClusterManager<T extends ClusterItem> implements
+        BaiduMap.OnMapStatusChangeListener, BaiduMap.OnMarkerClickListener {
+    private final MarkerManager mMarkerManager;
+    private final MarkerManager.Collection mMarkers;
+    private final MarkerManager.Collection mClusterMarkers;
+
+    private Algorithm<T> mAlgorithm;
+    private final ReadWriteLock mAlgorithmLock = new ReentrantReadWriteLock();
+    private ClusterRenderer<T> mRenderer;
+
+    private BaiduMap mMap;
+    private MapStatus mPreviousCameraPosition;
+    private ClusterTask mClusterTask;
+    private final ReadWriteLock mClusterTaskLock = new ReentrantReadWriteLock();
+
+    private OnClusterItemClickListener<T> mOnClusterItemClickListener;
+    private OnClusterInfoWindowClickListener<T> mOnClusterInfoWindowClickListener;
+    private OnClusterItemInfoWindowClickListener<T> mOnClusterItemInfoWindowClickListener;
+    private OnClusterClickListener<T> mOnClusterClickListener;
+
+    public ClusterManager(Context context, BaiduMap map) {
+        this(context, map, new MarkerManager(map));
+    }
+
+    public ClusterManager(Context context, BaiduMap map, MarkerManager markerManager) {
+        mMap = map;
+        mMarkerManager = markerManager;
+        mClusterMarkers = markerManager.newCollection();
+        mMarkers = markerManager.newCollection();
+        mRenderer = new DefaultClusterRenderer<T>(context, map, this);
+        mAlgorithm = new PreCachingAlgorithmDecorator<T>(new NonHierarchicalDistanceBasedAlgorithm<T>());
+        mClusterTask = new ClusterTask();
+        mRenderer.onAdd();
+    }
+
+    public MarkerManager.Collection getMarkerCollection() {
+        return mMarkers;
+    }
+
+    public MarkerManager.Collection getClusterMarkerCollection() {
+        return mClusterMarkers;
+    }
+
+    public MarkerManager getMarkerManager() {
+        return mMarkerManager;
+    }
+
+    public void setRenderer(ClusterRenderer<T> view) {
+        mRenderer.setOnClusterClickListener(null);
+        mRenderer.setOnClusterItemClickListener(null);
+        mClusterMarkers.clear();
+        mMarkers.clear();
+        mRenderer.onRemove();
+        mRenderer = view;
+        mRenderer.onAdd();
+        mRenderer.setOnClusterClickListener(mOnClusterClickListener);
+        mRenderer.setOnClusterInfoWindowClickListener(mOnClusterInfoWindowClickListener);
+        mRenderer.setOnClusterItemClickListener(mOnClusterItemClickListener);
+        mRenderer.setOnClusterItemInfoWindowClickListener(mOnClusterItemInfoWindowClickListener);
+        cluster();
+    }
+
+    public void setAlgorithm(Algorithm<T> algorithm) {
+        mAlgorithmLock.writeLock().lock();
+        try {
+            if (mAlgorithm != null) {
+                algorithm.addItems(mAlgorithm.getItems());
+            }
+            mAlgorithm = new PreCachingAlgorithmDecorator<T>(algorithm);
+        } finally {
+            mAlgorithmLock.writeLock().unlock();
+        }
+        cluster();
+    }
+
+    public void clearItems() {
+        mAlgorithmLock.writeLock().lock();
+        try {
+            mAlgorithm.clearItems();
+        } finally {
+            mAlgorithmLock.writeLock().unlock();
+        }
+    }
+
+    public void addItems(Collection<T> items) {
+        mAlgorithmLock.writeLock().lock();
+        try {
+            mAlgorithm.addItems(items);
+        } finally {
+            mAlgorithmLock.writeLock().unlock();
+        }
+
+    }
+
+    public void addItem(T myItem) {
+        mAlgorithmLock.writeLock().lock();
+        try {
+            mAlgorithm.addItem(myItem);
+        } finally {
+            mAlgorithmLock.writeLock().unlock();
+        }
+    }
+
+    public void removeItem(T item) {
+        mAlgorithmLock.writeLock().lock();
+        try {
+            mAlgorithm.removeItem(item);
+        } finally {
+            mAlgorithmLock.writeLock().unlock();
+        }
+    }
+
+    /**
+     * Force a re-cluster. You may want to call this after adding new item(s).
+     */
+    public void cluster() {
+        mClusterTaskLock.writeLock().lock();
+        try {
+            // Attempt to cancel the in-flight request.
+            mClusterTask.cancel(true);
+            mClusterTask = new ClusterTask();
+
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
+                mClusterTask.execute(mMap.getMapStatus().zoom);
+            } else {
+                mClusterTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, mMap.getMapStatus().zoom);
+            }
+        } finally {
+            mClusterTaskLock.writeLock().unlock();
+        }
+    }
+
+
+    @Override
+    public void onMapStatusChangeStart(MapStatus mapStatus) {
+
+    }
+
+    @Override
+    public void onMapStatusChangeStart(MapStatus status, int reason) {
+
+    }
+
+    @Override
+    public void onMapStatusChange(MapStatus mapStatus) {
+        if (mRenderer instanceof BaiduMap.OnMapStatusChangeListener) {
+            ((BaiduMap.OnMapStatusChangeListener) mRenderer).onMapStatusChange(mapStatus);
+        }
+
+        // Don't re-compute clusters if the map has just been panned/tilted/rotated.
+        MapStatus position = mMap.getMapStatus();
+        if (mPreviousCameraPosition != null && mPreviousCameraPosition.zoom == position.zoom) {
+            return;
+        }
+        mPreviousCameraPosition = mMap.getMapStatus();
+
+        cluster();
+    }
+
+    @Override
+    public void onMapStatusChangeFinish(MapStatus mapStatus) {
+
+    }
+
+    @Override
+    public boolean onMarkerClick(Marker marker) {
+        return getMarkerManager().onMarkerClick(marker);
+    }
+
+    /**
+     * Runs the clustering algorithm in a background thread, then re-paints when results come back.
+     */
+    private class ClusterTask extends AsyncTask<Float, Void, Set<? extends Cluster<T>>> {
+        @Override
+        protected Set<? extends Cluster<T>> doInBackground(Float... zoom) {
+            mAlgorithmLock.readLock().lock();
+            try {
+                return mAlgorithm.getClusters(zoom[0]);
+            } finally {
+                mAlgorithmLock.readLock().unlock();
+            }
+        }
+
+        @Override
+        protected void onPostExecute(Set<? extends Cluster<T>> clusters) {
+            mRenderer.onClustersChanged(clusters);
+        }
+    }
+
+    /**
+     * Sets a callback that's invoked when a Cluster is tapped. Note: For this listener to function,
+     * the ClusterManager must be added as a click listener to the map.
+     */
+    public void setOnClusterClickListener(OnClusterClickListener<T> listener) {
+        mOnClusterClickListener = listener;
+        mRenderer.setOnClusterClickListener(listener);
+    }
+
+    /**
+     * Sets a callback that's invoked when a Cluster is tapped. Note: For this listener to function,
+     * the ClusterManager must be added as a info window click listener to the map.
+     */
+    public void setOnClusterInfoWindowClickListener(OnClusterInfoWindowClickListener<T> listener) {
+        mOnClusterInfoWindowClickListener = listener;
+        mRenderer.setOnClusterInfoWindowClickListener(listener);
+    }
+
+    /**
+     * Sets a callback that's invoked when an individual ClusterItem is tapped. Note: For this
+     * listener to function, the ClusterManager must be added as a click listener to the map.
+     */
+    public void setOnClusterItemClickListener(OnClusterItemClickListener<T> listener) {
+        mOnClusterItemClickListener = listener;
+        mRenderer.setOnClusterItemClickListener(listener);
+    }
+
+    /**
+     * Sets a callback that's invoked when an individual ClusterItem's Info Window is tapped. Note: For this
+     * listener to function, the ClusterManager must be added as a info window click listener to the map.
+     */
+    public void setOnClusterItemInfoWindowClickListener(OnClusterItemInfoWindowClickListener<T> listener) {
+        mOnClusterItemInfoWindowClickListener = listener;
+        mRenderer.setOnClusterItemInfoWindowClickListener(listener);
+    }
+
+    /**
+     * Called when a Cluster is clicked.
+     */
+    public interface OnClusterClickListener<T extends ClusterItem> {
+        public boolean onClusterClick(Cluster<T> cluster);
+    }
+
+    /**
+     * Called when a Cluster's Info Window is clicked.
+     */
+    public interface OnClusterInfoWindowClickListener<T extends ClusterItem> {
+        public void onClusterInfoWindowClick(Cluster<T> cluster);
+    }
+
+    /**
+     * Called when an individual ClusterItem is clicked.
+     */
+    public interface OnClusterItemClickListener<T extends ClusterItem> {
+        public boolean onClusterItemClick(T item);
+    }
+
+    /**
+     * Called when an individual ClusterItem's Info Window is clicked.
+     */
+    public interface OnClusterItemInfoWindowClickListener<T extends ClusterItem> {
+        public void onClusterItemInfoWindowClick(T item);
+    }
+}

package/android/src/main/java/com/baidu/mapapi/clusterutil/clustering/algo/Algorithm.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2015 Baidu, Inc. All Rights Reserved.
+ */
+
+package com.baidu.mapapi.clusterutil.clustering.algo;
+
+
+import com.baidu.mapapi.clusterutil.clustering.Cluster;
+import com.baidu.mapapi.clusterutil.clustering.ClusterItem;
+
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * Logic for computing clusters
+ */
+public interface Algorithm<T extends ClusterItem> {
+    void addItem(T item);
+
+    void addItems(Collection<T> items);
+
+    void clearItems();
+
+    void removeItem(T item);
+
+    Set<? extends Cluster<T>> getClusters(double zoom);
+
+    Collection<T> getItems();
+}

package/android/src/main/java/com/baidu/mapapi/clusterutil/clustering/algo/NonHierarchicalDistanceBasedAlgorithm.java

@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2015 Baidu, Inc. All Rights Reserved.
+ */
+
+package com.baidu.mapapi.clusterutil.clustering.algo;
+
+import com.baidu.mapapi.clusterutil.clustering.Cluster;
+import com.baidu.mapapi.clusterutil.clustering.ClusterItem;
+import com.baidu.mapapi.clusterutil.projection.Bounds;
+import com.baidu.mapapi.clusterutil.projection.Point;
+import com.baidu.mapapi.clusterutil.projection.SphericalMercatorProjection;
+import com.baidu.mapapi.clusterutil.quadtree.PointQuadTree;
+import com.baidu.mapapi.model.LatLng;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A simple clustering algorithm with O(nlog n) performance. Resulting clusters are not
+ * hierarchical.
+ * <p/>
+ * High level algorithm:<br>
+ * 1. Iterate over items in the order they were added (candidate clusters).<br>
+ * 2. Create a cluster with the center of the item. <br>
+ * 3. Add all items that are within a certain distance to the cluster. <br>
+ * 4. Move any items out of an existing cluster if they are closer to another cluster. <br>
+ * 5. Remove those items from the list of candidate clusters.
+ * <p/>
+ * Clusters have the center of the first element (not the centroid of the items within it).
+ */
+public class NonHierarchicalDistanceBasedAlgorithm<T extends ClusterItem> implements Algorithm<T> {
+    public static final int MAX_DISTANCE_AT_ZOOM = 100; // essentially 100 dp.
+
+    /**
+     * Any modifications should be synchronized on mQuadTree.
+     */
+    private final Collection<QuadItem<T>> mItems = new ArrayList<QuadItem<T>>();
+
+    /**
+     * Any modifications should be synchronized on mQuadTree.
+     */
+    private final PointQuadTree<QuadItem<T>> mQuadTree = new PointQuadTree<QuadItem<T>>(0, 1, 0, 1);
+
+    private static final SphericalMercatorProjection PROJECTION = new SphericalMercatorProjection(1);
+
+    @Override
+    public void addItem(T item) {
+        final QuadItem<T> quadItem = new QuadItem<T>(item);
+        synchronized (mQuadTree) {
+            mItems.add(quadItem);
+            mQuadTree.add(quadItem);
+        }
+    }
+
+    @Override
+    public void addItems(Collection<T> items) {
+        for (T item : items) {
+            addItem(item);
+        }
+    }
+
+    @Override
+    public void clearItems() {
+        synchronized (mQuadTree) {
+            mItems.clear();
+            mQuadTree.clear();
+        }
+    }
+
+    @Override
+    public void removeItem(T item) {
+        // TODO: delegate QuadItem#hashCode and QuadItem#equals to its item.
+        throw new UnsupportedOperationException("NonHierarchicalDistanceBasedAlgorithm.remove not implemented");
+    }
+
+    /**
+     *  cluster算法核心
+     * @param zoom map的级别
+     * @return
+     */
+    @Override
+    public Set<? extends Cluster<T>> getClusters(double zoom) {
+        final int discreteZoom = (int) zoom;
+
+        final double zoomSpecificSpan = MAX_DISTANCE_AT_ZOOM / Math.pow(2, discreteZoom) / 256;
+
+        final Set<QuadItem<T>> visitedCandidates = new HashSet<QuadItem<T>>();
+        final Set<Cluster<T>> results = new HashSet<Cluster<T>>();
+        final Map<QuadItem<T>, Double> distanceToCluster = new HashMap<QuadItem<T>, Double>();
+        final Map<QuadItem<T>, StaticCluster<T>> itemToCluster =
+                new HashMap<QuadItem<T>, StaticCluster<T>>();
+
+        synchronized (mQuadTree) {
+            for (QuadItem<T> candidate : mItems) {
+                if (visitedCandidates.contains(candidate)) {
+                    // Candidate is already part of another cluster.
+                    continue;
+                }
+
+                Bounds searchBounds = createBoundsFromSpan(candidate.getPoint(), zoomSpecificSpan);
+                Collection<QuadItem<T>> clusterItems;
+                // search 某边界范围内的clusterItems
+                clusterItems = mQuadTree.search(searchBounds);
+                if (clusterItems.size() == 1) {
+                    // Only the current marker is in range. Just add the single item to the results.
+                    results.add(candidate);
+                    visitedCandidates.add(candidate);
+                    distanceToCluster.put(candidate, 0d);
+                    continue;
+                }
+                StaticCluster<T> cluster =
+                        new StaticCluster<T>(candidate.mClusterItem.getPosition());
+                results.add(cluster);
+
+                for (QuadItem<T> clusterItem : clusterItems) {
+                    Double existingDistance = distanceToCluster.get(clusterItem);
+                    double distance = distanceSquared(clusterItem.getPoint(), candidate.getPoint());
+                    if (existingDistance != null) {
+                        // Item already belongs to another cluster. Check if it's closer to this cluster.
+                        if (existingDistance < distance) {
+                            continue;
+                        }
+                        // Move item to the closer cluster.
+                        itemToCluster.get(clusterItem).remove(clusterItem.mClusterItem);
+                    }
+                    distanceToCluster.put(clusterItem, distance);
+                    cluster.add(clusterItem.mClusterItem);
+                    itemToCluster.put(clusterItem, cluster);
+                }
+                visitedCandidates.addAll(clusterItems);
+            }
+        }
+        return results;
+    }
+
+    @Override
+    public Collection<T> getItems() {
+        final List<T> items = new ArrayList<T>();
+        synchronized (mQuadTree) {
+            for (QuadItem<T> quadItem : mItems) {
+                items.add(quadItem.mClusterItem);
+            }
+        }
+        return items;
+    }
+
+    private double distanceSquared(Point a, Point b) {
+        return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
+    }
+
+    private Bounds createBoundsFromSpan(Point p, double span) {
+        // TODO: Use a span that takes into account the visual size of the marker, not just its
+        // LatLng.
+        double halfSpan = span / 2;
+        return new Bounds(
+                p.x - halfSpan, p.x + halfSpan,
+                p.y - halfSpan, p.y + halfSpan);
+    }
+
+    private static class QuadItem<T extends ClusterItem> implements PointQuadTree.Item, Cluster<T> {
+        private final T mClusterItem;
+        private final Point mPoint;
+        private final LatLng mPosition;
+        private Set<T> singletonSet;
+
+        private QuadItem(T item) {
+            mClusterItem = item;
+            mPosition = item.getPosition();
+            mPoint = PROJECTION.toPoint(mPosition);
+            singletonSet = Collections.singleton(mClusterItem);
+        }
+
+        @Override
+        public Point getPoint() {
+            return mPoint;
+        }
+
+        @Override
+        public LatLng getPosition() {
+            return mPosition;
+        }
+
+        @Override
+        public Set<T> getItems() {
+            return singletonSet;
+        }
+
+        @Override
+        public int getSize() {
+            return 1;
+        }
+    }
+}

package/android/src/main/java/com/baidu/mapapi/clusterutil/clustering/algo/PreCachingAlgorithmDecorator.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2015 Baidu, Inc. All Rights Reserved.
+ */
+
+package com.baidu.mapapi.clusterutil.clustering.algo;
+
+import android.util.LruCache;
+
+import com.baidu.mapapi.clusterutil.clustering.Cluster;
+import com.baidu.mapapi.clusterutil.clustering.ClusterItem;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * Optimistically fetch clusters for adjacent zoom levels, caching them as necessary.
+ */
+public class PreCachingAlgorithmDecorator<T extends ClusterItem> implements Algorithm<T> {
+    private final Algorithm<T> mAlgorithm;
+
+    // TODO: evaluate maxSize parameter for LruCache.
+    private final LruCache<Integer, Set<? extends Cluster<T>>> mCache =
+            new LruCache<Integer, Set<? extends Cluster<T>>>(5);
+    private final ReadWriteLock mCacheLock = new ReentrantReadWriteLock();
+
+    public PreCachingAlgorithmDecorator(Algorithm<T> algorithm) {
+        mAlgorithm = algorithm;
+    }
+
+    public void addItem(T item) {
+        mAlgorithm.addItem(item);
+        clearCache();
+    }
+
+    @Override
+    public void addItems(Collection<T> items) {
+        mAlgorithm.addItems(items);
+        clearCache();
+    }
+
+    @Override
+    public void clearItems() {
+        mAlgorithm.clearItems();
+        clearCache();
+    }
+
+    public void removeItem(T item) {
+        mAlgorithm.removeItem(item);
+        clearCache();
+    }
+
+    private void clearCache() {
+        mCache.evictAll();
+    }
+
+    @Override
+    public Set<? extends Cluster<T>> getClusters(double zoom) {
+        int discreteZoom = (int) zoom;
+        Set<? extends Cluster<T>> results = getClustersInternal(discreteZoom);
+        // TODO: Check if requests are already in-flight.
+        if (mCache.get(discreteZoom + 1) == null) {
+            new Thread(new PrecacheRunnable(discreteZoom + 1)).start();
+        }
+        if (mCache.get(discreteZoom - 1) == null) {
+            new Thread(new PrecacheRunnable(discreteZoom - 1)).start();
+        }
+        return results;
+    }
+
+    @Override
+    public Collection<T> getItems() {
+        return mAlgorithm.getItems();
+    }
+
+    private Set<? extends Cluster<T>> getClustersInternal(int discreteZoom) {
+        Set<? extends Cluster<T>> results;
+        mCacheLock.readLock().lock();
+        results = mCache.get(discreteZoom);
+        mCacheLock.readLock().unlock();
+
+        if (results == null) {
+            mCacheLock.writeLock().lock();
+            results = mCache.get(discreteZoom);
+            if (results == null) {
+                results = mAlgorithm.getClusters(discreteZoom);
+                mCache.put(discreteZoom, results);
+            }
+            mCacheLock.writeLock().unlock();
+        }
+        return results;
+    }
+
+    private class PrecacheRunnable implements Runnable {
+        private final int mZoom;
+
+        public PrecacheRunnable(int zoom) {
+            mZoom = zoom;
+        }
+
+        @Override
+        public void run() {
+            try {
+                // Wait between 500 - 1000 ms.
+                Thread.sleep((long) (Math.random() * 500 + 500));
+            } catch (InterruptedException e) {
+                // ignore. keep going.
+            }
+            getClustersInternal(mZoom);
+        }
+    }
+}

package/android/src/main/java/com/baidu/mapapi/clusterutil/clustering/algo/StaticCluster.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2015 Baidu, Inc. All Rights Reserved.
+ */
+
+package com.baidu.mapapi.clusterutil.clustering.algo;
+
+import com.baidu.mapapi.clusterutil.clustering.Cluster;
+import com.baidu.mapapi.clusterutil.clustering.ClusterItem;
+import com.baidu.mapapi.model.LatLng;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * A cluster whose center is determined upon creation.
+ */
+public class StaticCluster<T extends ClusterItem> implements Cluster<T> {
+    private final LatLng mCenter;
+    private final List<T> mItems = new ArrayList<T>();
+
+    public StaticCluster(LatLng center) {
+        mCenter = center;
+    }
+
+
+
+    public boolean add(T t) {
+        return mItems.add(t);
+    }
+
+    @Override
+    public LatLng getPosition() {
+        return mCenter;
+    }
+
+    public boolean remove(T t) {
+        return mItems.remove(t);
+    }
+
+    @Override
+    public Collection<T> getItems() {
+        return mItems;
+    }
+
+    @Override
+    public int getSize() {
+        return mItems.size();
+    }
+
+    @Override
+    public String toString() {
+        return "StaticCluster{"
+                + "mCenter=" + mCenter
+                + ", mItems.size=" + mItems.size()
+                + '}';
+    }
+}