MapView Markers

This example shows how to Add markers in bulk

  • Add markers in bulk to MapView

  • Click MapView to Add a marker with clicked point

    • position(point)
    • title(title)
    • snippet(snippet);
MapView Markers

For all code examples, refer to Android Maps SDK Code Examples

activity_marker.xml view source

1
<?xml version="1.0" encoding="utf-8"?>
2
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
3
    xmlns:app="http://schemas.android.com/apk/res-auto"
4
    xmlns:tools="http://schemas.android.com/tools"
5
    android:layout_width="match_parent"
6
    android:layout_height="match_parent"
7
    tools:context=".MainActivity">
8


9
    <ai.nextbillion.maps.core.MapView
10
        android:id="@+id/map_view"
11
        android:layout_width="match_parent"
12
        android:layout_height="match_parent"
13
        app:nbmap_uiAttribution="false"
14
        app:nbmap_cameraTargetLat="53.550813508267716"
15
        app:nbmap_cameraTargetLng="9.992248999933745"
16
        app:nbmap_cameraZoom="12" />
17


18


19
    <ImageView
20
        android:id="@+id/iv_back"
21
        android:layout_width="40dp"
22
        android:layout_height="40dp"
23
        android:layout_marginLeft="16dp"
24
        app:layout_constraintTop_toTopOf="parent"
25
        app:layout_constraintLeft_toLeftOf="parent"
26
        android:layout_marginTop="16dp"
27
        android:background="@drawable/circle_white_bg"
28
        android:src="@drawable/icon_back"
29
        app:tint="@color/color_back_icon"/>
30


31
</androidx.constraintlayout.widget.ConstraintLayout>

MarkersActivity view source

1
package ai.nextbillion;
2


3
import android.app.ProgressDialog;
4
import android.graphics.PointF;
5
import android.os.AsyncTask;
6
import android.os.Bundle;
7
import android.view.Menu;
8
import android.view.MenuItem;
9


10
import java.io.IOException;
11
import java.lang.ref.WeakReference;
12
import java.text.DecimalFormat;
13
import java.util.ArrayList;
14
import java.util.List;
15
import java.util.Random;
16


17
import ai.nextbillion.maps.annotations.MarkerOptions;
18
import ai.nextbillion.maps.core.MapView;
19
import ai.nextbillion.maps.core.NextbillionMap;
20
import ai.nextbillion.maps.geometry.LatLng;
21
import ai.nextbillion.utils.GeoParseUtil;
22
import androidx.appcompat.app.AppCompatActivity;
23


24
/**
25
 * Test activity showcasing adding a large amount of Markers.
26
 */
27
public class MarkersActivity extends AppCompatActivity {
28


29
    private NextbillionMap nextbillionMap;
30
    private MapView mapView;
31
    private List<LatLng> locations;
32
    private ProgressDialog progressDialog;
33
    private static final DecimalFormat LAT_LON_FORMATTER = new DecimalFormat("#.#####");
34
    List<MarkerOptions> markerOptionsList = new ArrayList<>();
35


36
    @Override
37
    protected void onCreate(Bundle savedInstanceState) {
38
        super.onCreate(savedInstanceState);
39
        setContentView(R.layout.activity_marker);
40


41
        mapView = findViewById(R.id.mapView);
42
        mapView.onCreate(savedInstanceState);
43
        mapView.getMapAsync(this::initMap);
44
    }
45


46


47
    private void initMap(NextbillionMap nextbillionMap) {
48
        this.nextbillionMap =  nextbillionMap;
49
        nextbillionMap.setStyle(StyleConstants.NBMAP_STREETS);
50
        if (locations == null) {
51
            progressDialog = ProgressDialog.show(this, "Loading", "Fetching markers", false);
52
            new LoadLocationTask(this, 100).execute();
53
        } else {
54
            showMarkers(100);
55
        }
56
        nextbillionMap.addOnMapLongClickListener(point -> {
57
            addMarker(point);
58
            return false;
59
        });
60


61
        nextbillionMap.addOnMapClickListener(point -> {
62
            addMarker(point);
63
            return false;
64
        });
65
    }
66


67
    @Override
68
    public boolean onCreateOptionsMenu(Menu menu) {
69
        getMenuInflater().inflate(R.menu.menu_press_for_marker, menu);
70
        return true;
71
    }
72


73
    private void addMarker(LatLng point) {
74
        final PointF pixel = nextbillionMap.getProjection().toScreenLocation(point);
75


76
        String title = LAT_LON_FORMATTER.format(point.getLatitude()) + ", "
77
                + LAT_LON_FORMATTER.format(point.getLongitude());
78
        String snippet = "X = " + (int) pixel.x + ", Y = " + (int) pixel.y;
79


80
        MarkerOptions marker = new MarkerOptions()
81
                .position(point)
82
                .title(title)
83
                .snippet(snippet);
84


85
        markerOptionsList.add(marker);
86
        nextbillionMap.addMarker(marker);
87


88
    }
89


90
    private void onLatLngListLoaded(List<LatLng> latLngs, int amount) {
91
        progressDialog.hide();
92
        locations = latLngs;
93
        showMarkers(amount);
94
    }
95


96
    private void showMarkers(int amount) {
97
        if (nextbillionMap == null || locations == null || mapView.isDestroyed()) {
98
            return;
99
        }
100


101
        nextbillionMap.clear();
102
        if (locations.size() < amount) {
103
            amount = locations.size();
104
        }
105


106
        showGlMarkers(amount);
107
    }
108


109
    private void showGlMarkers(int amount) {
110
        DecimalFormat formatter = new DecimalFormat("#.#####");
111
        Random random = new Random();
112
        int randomIndex;
113


114
        for (int i = 0; i < amount; i++) {
115
            randomIndex = random.nextInt(locations.size());
116
            LatLng latLng = locations.get(randomIndex);
117
            markerOptionsList.add(new MarkerOptions()
118
                    .position(latLng)
119
                    .title(String.valueOf(i))
120
                    .snippet(formatter.format(latLng.getLatitude()) + ", " + formatter.format(latLng.getLongitude())));
121
        }
122


123
        nextbillionMap.addMarkers(markerOptionsList);
124
    }
125


126
    private void resetMap() {
127
        if (nextbillionMap == null) {
128
            return;
129
        }
130
        markerOptionsList.clear();
131
        nextbillionMap.removeAnnotations();
132
    }
133


134
    @Override
135
    protected void onStart() {
136
        super.onStart();
137
        mapView.onStart();
138
    }
139


140
    @Override
141
    protected void onResume() {
142
        super.onResume();
143
        mapView.onResume();
144
    }
145


146
    @Override
147
    protected void onPause() {
148
        super.onPause();
149
        mapView.onPause();
150
    }
151


152
    @Override
153
    protected void onStop() {
154
        super.onStop();
155
        mapView.onStop();
156
    }
157


158
    @Override
159
    protected void onSaveInstanceState(Bundle outState) {
160
        super.onSaveInstanceState(outState);
161
        mapView.onSaveInstanceState(outState);
162
    }
163


164
    @Override
165
    protected void onDestroy() {
166
        super.onDestroy();
167
        if (progressDialog != null) {
168
            progressDialog.dismiss();
169
        }
170
        mapView.onDestroy();
171
    }
172


173
    @Override
174
    public void onLowMemory() {
175
        super.onLowMemory();
176
        mapView.onLowMemory();
177
    }
178


179
    private static class LoadLocationTask extends AsyncTask<Void, Integer, List<LatLng>> {
180


181
        private WeakReference<MarkersActivity> activity;
182
        private int amount;
183


184
        private LoadLocationTask(MarkersActivity activity, int amount) {
185
            this.amount = amount;
186
            this.activity = new WeakReference<>(activity);
187
        }
188


189
        @Override
190
        protected List<LatLng> doInBackground(Void... params) {
191
            MarkersActivity activity = this.activity.get();
192
            if (activity != null) {
193
                String json = null;
194
                try {
195
                    json = GeoParseUtil.loadStringFromAssets(activity.getApplicationContext(), "points.geojson");
196
                } catch (IOException exception) {
197
                }
198


199
                if (json != null) {
200
                    return GeoParseUtil.parseGeoJsonCoordinates(json);
201
                }
202
            }
203
            return null;
204
        }
205


206
        @Override
207
        protected void onPostExecute(List<LatLng> locations) {
208
            super.onPostExecute(locations);
209
            MarkersActivity activity = this.activity.get();
210
            if (activity != null) {
211
                activity.onLatLngListLoaded(locations, amount);
212
            }
213
        }
214
    }
215


216
    @Override
217
    public boolean onOptionsItemSelected(MenuItem item) {
218
        switch (item.getItemId()) {
219
            case R.id.menuItemReset:
220
                resetMap();
221
                return true;
222
            default:
223
                return super.onOptionsItemSelected(item);
224
        }
225
    }
226
}

The given code is an Android activity that demonstrates different functionalities related to working with markers on a map using the Nextbillion Maps SDK. The activity allows users to add markers in bulk, add markers by clicking on the map, and reset the map.

initMapView:

  • The onCreate method initializes the MapView by setting the content view and obtaining a reference to it using findViewById. Then, the mapView.onCreate(savedInstanceState) method is called to initialize the MapView and pass the saved instance state.

add markers in bulk to MapView:

  • The showGlMarkers method is responsible for adding markers in bulk to the NextbillionMap.

  • Generates random indexes and retrieves corresponding LatLng coordinates from the locations list.

  • Creates a MarkerOptions object for each coordinate, including a title and snippet, and adds them to the markerOptionsList.

  • Finally, the nextbillionMap.addMarkers(markerOptionsList) method is called to add all the markers to the map.

click MapView to add a marker:

  • The addOnMapLongClickListener and addOnMapClickListener methods are used to listen for long click and click events on the map, respectively. When a long click or click occurs, the addMarker method is called with the clicked LatLng point.

  • The method converts the LatLng to a PointF using nextbillionMap.getProjection().toScreenLocation(point).

  • It creates a MarkerOptions object with the position, title, and snippet based on the clicked point and adds it to both the markerOptionsList and the nextbillionMap using nextbillionMap.addMarker(marker).

Overall, the code demonstrates how to initialize the MapView, add markers in bulk to the NextbillionMap, and add markers by clicking on the map.

PRODUCTS

SOLUTIONS

COMPARE

DEVELOPERS

GUIDES

RESOURCES

COMPANY

logo

UNITED STATES

NEXTBILLION.AI, INC.
21 E State Street,
Suite 200,
Columbus, OH 43215

SINGAPORE

#32-01, 80 Raffles Place, UOB Plaza,
Singapore, 048624

© 2024 NextBillion.ai all rights reserved.

Privacy PolicyTerms of ServiceSLASupport Services Agreement