Polylines performance issues on GoogleMaps API v2

Question

I'm programming an app for android, in which i have to represent certain block facades. For this purpose, i draw a polyline for each relevant block facade (very simple polylines, 2 point lines actually...).

Worst case scenario, there could be up to 100k polylines.

My problem is that i'm running tests with about 3000 lines and it's already really slow. I have no problem with getting the data to show, and no problem drawing the lines, but the map becomes laggy when more than 1k lines are drawn.

I create a PolylineOptions for each polyline, and then draw it and store it in a variable like this:

PolylineOptions options = new PolylineOptions();
options.add(latlon1, latlon2);
options.width(5);
options.color(Color.RED);
Polyline myPolyline = map.addPolyline(options);
myPolyline.setVisible(true);
myPolylines.add(myPolyline);

I tried not storing them (though this is necessary for later processing) in case it was a memory issue, but didn't make a difference... Also, when storing them, the rest of the app works fluently (some extra buttons/text fields), it's just the map that becomes slow (when moving/zooming).

Oh, and I'm using mapfragment class of google maps api v2.

So, the question being: Is there any way to improve the map performance?

Thanks in advance.

EDIT: The polylines are all visible at once. To avoid drawing unnecessary lines I added a "previous step" in which i draw circles that represent the amount of facades with the fill color (green to red) and only show the lines when a circle is selected and the user asks for the detailed view.

EDIT2: Here's what i'm trying to accomplish (it's from a mapguide map, but i'm trying to replicate on android)

Answer 1

If the polylines are not changing, I would draw them on background tiles rather than using the maps polyline feature.

For an example how to draw shapes based on LatLng-Coordinates into tiles, see my answer to this SO question

Answer 2

instead of plotting everything all at once only plot what you can see.

so you would get the bounds of the visable map

VisibleRegion vr = map.getProjection().getVisibleRegion();
bounds = vr.latLngBounds;

then check if you line is inside the bounds of the visible region is it is then plot the line

doing this will allow you to run your code in an asynctask where you can use a handler to call back to the main thread to plot a line when you need to.

you also have to override onCameraChange to know when the VisibleRegion changes ie. you mode the map. there are also other things you will have to do with this method like keeping track of if a line was plotted or not so you dont plot the same line many times

Answer 3

I'm using a asynctask to create polylineoption with 50 coordinates each and in publishprogress method I add the polyline to the map. If it does run too long and it doesn't I still have a progressdialog that the user can cancel the task with the back button. My largest test was for 3000 coordinates from sqllite database. However with two coordinates per polylineoption this code would get bogged down calling publishprogress so you'd have to stack up a couple dozen of the two coordinate polylines then add them to the map in the publishprogress method. PublishProgress takes an array so it wouldn't be difficult to pass in 50 polylineoptions. In debug with the 50 coordinates per polyline you can see the polylines being drawn on the map. In live mode the polylines just show up in about a second on my cheap $50 test phone.

Note: I do all my asynctasks as seperate .java files so I can pass in whatever I need in a constructor and so I have the same cancelMe() code. Most of the code I use is below I've omitted the database stuff because it will different for everyone.

public class TaskParseKmldb extends AsyncTask<KmlSummary, PolylineOptions, Boolean>
        implements OnCancelListener {

public interface TaskParseKmldbCallback {
    void onTaskParseKmldbComplete(boolean success);
}


public TaskParseKmldb(Activity activity, KmlSummary kmlSummary, GoogleMap mMap,
            ProgressDialog pd) {
    this.activity = activity;
    this.kmlSummary = kmlSummary;
    this.mMap = mMap;
    this.pd = pd;
    // determine if calling activity has implemented the callback interface
    callback = (TaskParseKmldbCallback.class.isAssignableFrom(activity
.getClass())) ? (TaskParseKmldbCallback) activity : null;   
    }

... setup a process dialog listener for the onCanceled routine.

@Override
    protected void onPreExecute() {
        pd.setOnCancelListener(this);
        pd.setMessage("Loading Recorded Route...");
        pd.show();
    }


@Override
protected void onCancelled(Boolean result) {
    if (pd != null) {
        pd.dismiss();
        pd = null;
    }
    if (callback != null) {
        callback.onTaskParseKmldbComplete(result);
    }
}

@Override
    public void onCancel(DialogInterface dialog) {
        cancelMe(); // this just gracefully cancels the task.
    }

public void cancelMe() {
    if (!getStatus().equals(Status.FINISHED)) {
        // not canceled
        if (!isCancelled()) {
            cancel(false);
            try {
                get();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (CancellationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

... somewhere in doInBackground

if (progress.getPoints().size() > 0) {
                publishProgress(progress);
                ret = true;
            }


protected void onProgressUpdate(PolylineOptions... progress) {
        if (isCancelled()) {
            return;
        }
        if (progress[0] != null) {
            // add the poly line to the map
            // save the polyline returned by the map for later use
            polylines.add(mMap.addPolyline(progress[0]));
        }
    }

...

@Override
protected void onPostExecute(Boolean result) {

    if (pd != null) {
        pd.dismiss();
        pd = null;
    }