细读百度地图点聚合源码(下)---Renderer类解析

Posted 2020-07-07 Jaivne_Kuang

上一篇文章分析了ClusterMananger的整体结构和核心算法 细读百度地图点聚合源码(上)，此文是接着上一篇来的。

在本文中，我们将学习如何在UI线程中做大量的操作，并且不会造成界面卡顿。

上次我们讲到ClusterManager类中的cluster()方法，调用ClusterTask后台线程处理核心算法，既然有doInBackground()后台任务函数，就会有onPostExecute()函数来处理后台线程返回的结果，这一篇我们就分析怎么处理返回的结果。

那么我们就从返回的结果开始吧！

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);
        }
    }

上面就是ClusterTask的源码，后台任务处理算法，然后返回数据给主线程，返回的就是一个Set<? extends Cluster<T>>类型的对象,就是一个包含若干个cluster对象的集合，而cluster对象又是一个包含若干MyItem(implements ClusterItem)的集合。

并且，每个cluster中的那些MyItem都是确定可以聚合成一个点的。

那到底要怎么处理这个cluster集合呢？

我们看到是mRenderer来处理的，就是源码中DefaultClusterRenderer类，当然我们也可以继承这个类来实现我们自己的Renderer类，这个等有需求再细说吧。

我们还是先来分析DefaultClusterRenderer这个类究竟做了些什么处理。

一切都是从onClustersChanged(clusters)这个方法开始(该方法从ClusterRenderer接口实现而来)。
@Override
    public void onClustersChanged(Set<? extends Cluster<T>> clusters) {
        mViewModifier.queue(clusters);
    }
这个方法很简单，里面只有一句代码，所以我们还得往里面跟踪。

至此我们会有两个疑问：mViewModifier是什么东东？queue()函数又是做什么用的呢？

ViewModifier其实是一个继承于Handler的类，内部只有两个函数：handleMessage()和queue()

我们先来看queue()函数：

public void queue(Set<? extends Cluster<T>> clusters) {
            synchronized (this) {
                // Overwrite any pending cluster tasks - we don't care about intermediate states.
                mNextClusters = new RenderTask(clusters);
            }
            sendEmptyMessage(RUN_TASK);
        }

在函数内部创建一个RenderTask对象，这是一个Runnable接口的实现类，也就是一个未启动的线程。

然后发送一条Message给handleMessage函数。大家应该可以猜到，在handleMessage中肯定会启动这个线程。

下面是handleMessage中的代码：

@Override
        public void handleMessage(Message msg) {
            if (msg.what == TASK_FINISHED) {//线程执行完成
                mViewModificationInProgress = false;//标记线程已经完成
                if (mNextClusters != null) {//如果有新任务还未执行，则再次启动线程
                    // Run the task that was queued up.
                    sendEmptyMessage(RUN_TASK);
                }
                return;
            }
            
            removeMessages(RUN_TASK);

            if (mViewModificationInProgress) {
                // Busy - wait for the callback.
                return;
            }

            if (mNextClusters == null) {
                // Nothing to do.
                return;
            }

            RenderTask renderTask;
            synchronized (this) {
                renderTask = mNextClusters;
                mNextClusters = null;
                mViewModificationInProgress = true;//标记线程正在运行
            }

            renderTask.setCallback(new Runnable() { //设置线程完成时的回调
                @Override
                public void run() {
                    sendEmptyMessage(TASK_FINISHED);//线程完成后，发送消息给自己
                }
            });
            renderTask.setProjection(mMap.getProjection());//无作用
            renderTask.setMapZoom(mMap.getMapStatus().zoom);//设置最新的地图级别
            new Thread(renderTask).start();//启动线程
        }

也不复杂，总的来说就一句话：启动一个线程，这个线程就是RenderTask。

程序执行到这里，我们其实只做了一件事情——启动了一个叫做RenderTask的线程。

那么，RenderTask究竟是何方神圣呢？

从上面的代码中可以看到，在启动线程之前对RenderTask进行了一些设置，所以在分析它的具体功能前，先看看这些设置有什么作用。

首先是setProjection()方法，此方法在现在的这份源码中没有任何作用。

然后是setMapZoom()方法，看一下源码

public void setMapZoom(float zoom) {
            this.mMapZoom = zoom;
            this.mSphericalMercatorProjection =
                    new SphericalMercatorProjection(256 * Math.pow(2, Math.min(zoom, mZoom)));
        }
可以看到，此方法中会保存当前地图的zoom值，然后创建一个SphericalMercatorProjection对象，它在上一篇核心算法中也出现过，用来实现position(经纬度)和point（二维坐标点）之间的转换。

为了计算点与点之间的距离，我们需要将position转换成point，而为了在地图上绘制marker，我们又需要将point转换成position。

这个转换就公式我就不多分析了，纯数学题。值得一提的是在创建SphericalMercatorProjection对象时传入的参数，其实就是根据zoom计算得到的worldWidth(计算公式：worldWidth = 256 * zoom^2)。至于mZoom，是保存的上一次的zoom值。

其实，zoom值的大小跟最终结果关系不是特别大，唯一的影响就是转换position和point的精度。不知道大家能不能理解，不能理解的话就多看几遍吧。

然后，就是RenderTask最重要的run()方法了。

代码逻辑不算特别复杂，还是采用代码+注释的方式来分析吧！

public void run() {
            if (clusters.equals(DefaultClusterRenderer.this.mClusters)) {
                mCallback.run();//判断如果新的clusters等于上一次保存的clusters，直接return出去
                return;
            }

            final MarkerModifier markerModifier = new MarkerModifier();//这个类处理显示和动画

            final float zoom = mMapZoom;//最新的zoom值
            final boolean zoomingIn = zoom > mZoom;//mZoom为上一次保存的zoom值
            final float zoomDelta = zoom - mZoom;//zoom变化量级，超过一定量级就不执行动画了

            final Set<MarkerWithPosition> markersToRemove = mMarkers;//需呀删除的点。请思考什么样的点需要被删除？
            final LatLngBounds visibleBounds = mMap.getMapStatus().bound;//地图在手机屏幕上的可见范围

            //1.添加点
            // 找出所有屏幕上的原来的cluster中心点，在增加点的时候有些动画需要用到这些点
            List<Point> existingClustersOnScreen = null;
            if (DefaultClusterRenderer.this.mClusters != null && SHOULD_ANIMATE) {
                existingClustersOnScreen = new ArrayList<Point>();
                for (Cluster<T> c : DefaultClusterRenderer.this.mClusters) { //迭代上一次保存的clusters
                    if (shouldRenderAsCluster(c) && visibleBounds.contains(c.getPosition())) {//只有已经聚合了的cluster才可以新增点
                        Point point = mSphericalMercatorProjection.toPoint(c.getPosition());//position转换成point
                        existingClustersOnScreen.add(point);//保存屏幕上已经聚合的cluster
                    }
                }
            }

            // Create the new markers and animate them to their new positions.
            final Set<MarkerWithPosition> newMarkers = Collections.newSetFromMap( 
                    new ConcurrentHashMap<MarkerWithPosition, Boolean>());//保存新的clusters中需要显示的点,转成MarkerWithPosition类型
            for (Cluster<T> c : clusters) {             //迭代新的clusters
                boolean onScreen = visibleBounds.contains(c.getPosition());//是否在屏幕内
                if (zoomingIn && onScreen && SHOULD_ANIMATE) { //地图放大 + 此cluster在屏幕内 + 可以动画(SDK版本>11)
                    Point point = mSphericalMercatorProjection.toPoint(c.getPosition());//position转成point
                    Point closest = findClosestCluster(existingClustersOnScreen, point);//找出与这个cluster距离最近的原屏幕上的点
                    if (closest != null) {//存在，则实现动画
                        LatLng animateTo = mSphericalMercatorProjection.toLatLng(closest);
                        markerModifier.add(true, new CreateMarkerTask(c, newMarkers, animateTo));
                    } else {//不存在，则直接添加不生成动画
                        markerModifier.add(true, new CreateMarkerTask(c, newMarkers, null));
                    }
                } else {//直接添加点，不生成动画
                    markerModifier.add(onScreen, new CreateMarkerTask(c, newMarkers, null));
                }
            }

            // 2.等待添加点的任务完成
            markerModifier.waitUntilFree();

            // 把newMarkers中的点从markersToRemove中移除，markersToRemove中的点都是需要从地图上移除的
            markersToRemove.removeAll(newMarkers);

            //3.移除点
            // 找出现在屏幕上显示的cluster中心点，在移除点时需要用到这些点来实现动画
            List<Point> newClustersOnScreen = null;
            if (SHOULD_ANIMATE) {
                newClustersOnScreen = new ArrayList<Point>();
                for (Cluster<T> c : clusters) {
                    if (shouldRenderAsCluster(c) && visibleBounds.contains(c.getPosition())) {
                        Point p = mSphericalMercatorProjection.toPoint(c.getPosition());
                        newClustersOnScreen.add(p);
                    }
                }
            }
            
            for (final MarkerWithPosition marker : markersToRemove) { //迭代所有需要移除的点
                boolean onScreen = visibleBounds.contains(marker.position);

                if (!zoomingIn && zoomDelta > -3 && onScreen && SHOULD_ANIMATE) { // 地图缩小 + zoom改变不超过3
                    final Point point = mSphericalMercatorProjection.toPoint(marker.position);
                    final Point closest = findClosestCluster(newClustersOnScreen, point);//找出最近的cluster
                    if (closest != null) {
                        LatLng animateTo = mSphericalMercatorProjection.toLatLng(closest);//动画移动的终点
                        markerModifier.animateThenRemove(marker, marker.position, animateTo);
                    } else {
                        markerModifier.remove(true, marker.marker);//无动画
                    }
                } else {
                    markerModifier.remove(onScreen, marker.marker);//无动画
                }
            }
            //等待移除点的任务完成
            markerModifier.waitUntilFree();

            mMarkers = newMarkers;//保存新的点
            DefaultClusterRenderer.this.mClusters = clusters;
            mZoom = zoom;//保存最新的zoom

            mCallback.run();//执行线程执行完成的回调函数
        }

首先，有两个方法需要说明一下。

shouldRenderAsCluster(cluster) ----- 判断cluster是否能聚合，这一步判断的是cluster中包含的ClusterItem的数量。

/**
     * Determine whether the cluster should be rendered as individual markers or a cluster.
     */
    protected boolean shouldRenderAsCluster(Cluster<T> cluster) {
        return cluster.getSize() > MIN_CLUSTER_SIZE;
    }
findClosestCluster(existingClustersOnScreen, point) ----- 查找最近的cluster。这个查找过程是设定了一个最小距离minDistSquared,如果没有小于minDistSquared的cluster就返回null。
private static Point findClosestCluster(List<Point> markers, Point point) {
        if (markers == null || markers.isEmpty()) {
            return null;
        }
        
        double minDistSquared = MAX_DISTANCE_AT_ZOOM * MAX_DISTANCE_AT_ZOOM;
        Point closest = null;
        for (Point candidate : markers) {
            double dist = distanceSquared(candidate, point);
            if (dist < minDistSquared) {
                closest = candidate;
                minDistSquared = dist;
            }
        }
        return closest;
    }

然后，有个类需要重点介绍----MarkerModifier。
MarkerModifier是一个Handler，这也是前篇所说的很精妙的在主线程中做大量工作的方法。
从名称就可以知道，这个是处理地图上Marker的修改。
private MarkerModifier() {
            super(Looper.getMainLooper());
        }
上面是它的构造函数，注意Looper.getMainLooper（)
我们知道Handler必须绑定一个Looper对象，而每个线程有且仅有一个Looper对象。但是MarkerModifier绑定的是MainLooper，也就是说它执行的所有内容，全部都在主线程中操作！！！！

此Handler实现了接口MessageQueue.IdleHandler，在读这份源码之前，楼主并不知道这是个什么东东，所以理解得也不一定对，各位最好自己去查一下。
MessageQueue.IdleHandler就是在系统空闲(Idle)状态时调用接口定义的queueIdle()方法，这个方法在实现接口时必须重写。
放在这个项目中，就是在系统空闲的时候，会自动调用MarkerModifier的handleMessage()方法。这样即可以做大量操作，也不会造成系统卡顿。
每次调用MarkerModifier的add方法或者remove方法，都会发送一个Message给自己，以调用自己的handleMessage方法。
接下来，我们着重介绍handleMessage方法。上代码！
        @Override
        public void handleMessage(Message msg) {//把所有的新增和删除marker 以及动画的任务全部执行完成

            if (!mListenerAdded) {
                //添加Idle接口
                Looper.myQueue().addIdleHandler(this); //在主线程空闲时，发送BLANK消息执行点聚合动作
                mListenerAdded = true;
            }
            removeMessages(BLANK);
            lock.lock();
            try {

                // 每次执行10个任务
                // 分批次执行所有任务（增加，删除，动画）,避免系统卡顿
                for (int i = 0; i < 10; i++) {
                    performNextTask();//执行一个任务
                }

                if (!isBusy()) {//是否执行完所有任务
                    mListenerAdded = false;
                    //移除idle接口
                    Looper.myQueue().removeIdleHandler(this);//所有子线程全部执行完成
                    // 唤醒所有等待的线程（可以回头去看看RenderTask的run()方法）
                    busyCondition.signalAll();
                } else {
                    //本来这一句是不必要的，但是百度工程师说，某些情况下系统空闲状态不会成功调用queueIdle()方法
                    // 所以这里手动延迟10ms再次调用handleMessage
                    sendEmptyMessageDelayed(BLANK, 10);
                }
            } finally {
                lock.unlock();
            }
        }

到这里，整个源码就分析完了，其他一些方法都比较简单，就不多说了，大家自己看源码吧！！
ClusterDemo