private MapPolyline createPolyline() {
    ArrayList<GeoCoordinates> coordinates = new ArrayList<>();
    coordinates.add(new GeoCoordinates(52.53032, 13.37409));
    coordinates.add(new GeoCoordinates(52.5309, 13.3946));
    coordinates.add(new GeoCoordinates(52.53894, 13.39194));
    coordinates.add(new GeoCoordinates(52.54014, 13.37958));

    GeoPolyline geoPolyline;
    try {
        geoPolyline = new GeoPolyline(coordinates);
    } catch (InstantiationErrorException e) {
        // Thrown when less than two vertices.
        return null;
    }

    float widthInPixels = 20;
    Color lineColor = Color.valueOf(0, 0.56f, 0.54f, 0.63f);
    MapPolyline routeMapPolyline = null;
    try {
        routeMapPolyline = new MapPolyline(routeGeoPolyline, new MapPolyline.SolidRepresentation(
                new MapMeasureDependentRenderSize(RenderSize.Unit.PIXELS, widthInPixels),
                lineColor,
                LineCap.ROUND));
    } catch (MapPolyline.Representation.InstantiationException e) {
        Log.e("MapPolyline Representation Exception:", e.error.name());
    } catch (MapMeasureDependentRenderSize.InstantiationException e) {
        Log.e("MapMeasureDependentRenderSize Exception:", e.error.name());
    }

    return mapPolyline;
}

private fun createPolyline(): MapPolyline? {
    val coordinates = ArrayList<GeoCoordinates>()
    coordinates.add(GeoCoordinates(52.53032, 13.37409))
    coordinates.add(GeoCoordinates(52.5309, 13.3946))
    coordinates.add(GeoCoordinates(52.53894, 13.39194))
    coordinates.add(GeoCoordinates(52.54014, 13.37958))

    val geoPolyline: GeoPolyline
    try {
        geoPolyline = GeoPolyline(coordinates)
    } catch (e: InstantiationErrorException) {
        // Thrown when less than two vertices.
        return null
    }

    val widthInPixels = 20f
    val lineColor: Color = Color(0f, 0.56.toFloat(), 0.54.toFloat(), 0.63.toFloat())
    var mapPolyline: MapPolyline? = null
    try {
        mapPolyline = MapPolyline(
            geoPolyline, MapPolyline.SolidRepresentation(
                MapMeasureDependentRenderSize(RenderSize.Unit.PIXELS, widthInPixels.toDouble()),
                lineColor,
                LineCap.ROUND
            )
        )
    } catch (e: MapPolyline.Representation.InstantiationException) {
        Log.e("MapPolyline Representation Exception:", e.error.name)
    } catch (e: MapMeasureDependentRenderSize.InstantiationException) {
        Log.e("MapMeasureDependentRenderSize Exception:", e.error.name)
    }

    return mapPolyline
}

mapScene = mapView.getMapScene();

mapPolyline = createPolyline();
mapScene.addMapPolyline(mapPolyline);

mapScene = mapView.getMapScene()

mapPolyline = createPolyline()
mapScene.addMapPolyline(mapPolyline)

mapScene.removeMapPolyline(mapPolyline);

mapScene.removeMapPolyline(mapPolyline)

public void enableVisibilityRangesForPolyline(){
    ArrayList<MapMeasureRange> visibilityRanges = new ArrayList<>();
    visibilityRanges.add(new MapMeasureRange(MapMeasure.Kind.ZOOM_LEVEL,1,10));
    visibilityRanges.add(new MapMeasureRange(MapMeasure.Kind.ZOOM_LEVEL,11,22));

    // Sets the visibility ranges for this map polyline based on zoom levels.
    // Each range is half-open: [minimumZoomLevel, maximumZoomLevel],
    // meaning the polyline is visible at minimumZoomLevel but not at maximumZoomLevel.
    // The polyline is rendered only when the map zoom level falls within any of the defined ranges.
    mapPolyline.setVisibilityRanges(visibilityRanges);
}

fun enableVisibilityRangesForPolyline() {
    val visibilityRanges = ArrayList<MapMeasureRange>()

    visibilityRanges.add(MapMeasureRange(MapMeasure.Kind.ZOOM_LEVEL, 1.0, 10.0))
    visibilityRanges.add(MapMeasureRange(MapMeasure.Kind.ZOOM_LEVEL, 11.0, 22.0))

    // Sets the visibility ranges for this map polyline based on zoom levels.
    // Each range is half-open: [minimumZoomLevel, maximumZoomLevel],
    // meaning the polyline is visible at minimumZoomLevel but not at maximumZoomLevel.
    // The polyline is rendered only when the map zoom level falls within any of the defined ranges.
    mapPolyline?.visibilityRanges = visibilityRanges
}

private MapArrow createMapArrow() {
    ArrayList<GeoCoordinates> coordinates = new ArrayList<>();
    coordinates.add(new GeoCoordinates(52.53032, 13.37409));
    coordinates.add(new GeoCoordinates(52.5309, 13.3946));
    coordinates.add(new GeoCoordinates(52.53894, 13.39194));
    coordinates.add(new GeoCoordinates(52.54014, 13.37958));

    GeoPolyline geoPolyline;
    try {
        geoPolyline = new GeoPolyline(coordinates);
    } catch (InstantiationErrorException e) {
        // Thrown when less than two vertices.
        return null;
    }

    float widthInPixels = 20;
    Color lineColor = Color.valueOf(0, 0.56f, 0.54f, 0.63f); // RGBA
    MapArrow mapArrow = new MapArrow(geoPolyline, widthInPixels, lineColor);

    return mapArrow;
}

private fun createMapArrow(): MapArrow? {
    val coordinates = ArrayList<GeoCoordinates>()
    coordinates.add(GeoCoordinates(52.53032, 13.37409))
    coordinates.add(GeoCoordinates(52.5309, 13.3946))
    coordinates.add(GeoCoordinates(52.53894, 13.39194))
    coordinates.add(GeoCoordinates(52.54014, 13.37958))

    val geoPolyline: GeoPolyline
    try {
        geoPolyline = GeoPolyline(coordinates)
    } catch (e: InstantiationErrorException) {
        // Thrown when less than two vertices.
        return null
    }

    val widthInPixels = 20f
    val lineColor: Color = Color.valueOf(0f, 0.56f, 0.54f, 0.63f) // RGBA
    val mapArrow = MapArrow(geoPolyline, widthInPixels.toDouble(), lineColor)

    return mapArrow
}

mapScene = mapView.getMapScene();

mapArrow = createMapArrow();
mapScene.addMapArrow(mapArrow);

mapScene = mapView.getMapScene()

mapArrow = createMapArrow()
mapScene.addMapArrow(mapArrow)

mapScene.removeMapArrow(mapArrow);

mapScene.removeMapArrow(mapArrow)

private MapPolygon createPolygon() {
    ArrayList<GeoCoordinates> coordinates = new ArrayList<>();
    // Note that a polygon requires a clockwise order of the coordinates.
    coordinates.add(new GeoCoordinates(52.54014, 13.37958));
    coordinates.add(new GeoCoordinates(52.53894, 13.39194));
    coordinates.add(new GeoCoordinates(52.5309, 13.3946));
    coordinates.add(new GeoCoordinates(52.53032, 13.37409));

    GeoPolygon geoPolygon;
    try {
        geoPolygon = new GeoPolygon(coordinates);
    } catch (InstantiationErrorException e) {
        // Thrown when less than three vertices.
        return null;
    }

    Color fillColor = Color.valueOf(0, 0.56f, 0.54f, 0.63f); // RGBA
    MapPolygon mapPolygon = new MapPolygon(geoPolygon, fillColor);

    return mapPolygon;
}

private fun createPolygon(): MapPolygon? {
    val coordinates = ArrayList<GeoCoordinates>()
    // Note that a polygon requires a clockwise or counter-clockwise order of the coordinates.
    coordinates.add(GeoCoordinates(52.54014, 13.37958))
    coordinates.add(GeoCoordinates(52.53894, 13.39194))
    coordinates.add(GeoCoordinates(52.5309, 13.3946))
    coordinates.add(GeoCoordinates(52.53032, 13.37409))

    val geoPolygon: GeoPolygon
    try {
        geoPolygon = GeoPolygon(coordinates)
    } catch (e: InstantiationErrorException) {
        // Less than three vertices.
        return null
    }

    val fillColor: Color = Color.valueOf(0f, 0.56f, 0.54f, 0.63f) // RGBA
    val mapPolygon = MapPolygon(geoPolygon, fillColor)

    return mapPolygon
}

MapPolygon mapPolygon = createPolygon();
MapScene mapScene = mapView.getMapScene();
mapScene.addMapPolygon(mapPolygon);

val mapPolygon = createPolygon()
val mapScene = mapView.mapScene
mapScene.addMapPolygon(mapPolygon!!)

mapScene.removeMapPolygon(mapPolygon);

mapScene.removeMapPolygon(mapPolygon)

private MapPolygon createMapCircle() {
    float radiusInMeters = 300;
    GeoCircle geoCircle = new GeoCircle(new GeoCoordinates(52.530932, 13.384915), radiusInMeters);

    GeoPolygon geoPolygon = new GeoPolygon(geoCircle);
    Color fillColor = Color.valueOf(0, 0.56f, 0.54f, 0.63f); // RGBA
    MapPolygon mapPolygon = new MapPolygon(geoPolygon, fillColor);

    return mapPolygon;
}

private fun createMapCircle(): MapPolygon {
    val radiusInMeters = 300f
    val geoCircle = GeoCircle(GeoCoordinates(52.51760485151816, 13.380312380535472), radiusInMeters.toDouble())

    val geoPolygon = GeoPolygon(geoCircle)
    val fillColor: Color = Color.valueOf(0f, 0.56f, 0.54f, 0.63f) // RGBA
    val mapPolygon = MapPolygon(geoPolygon, fillColor)

    return mapPolygon
}

MapImage mapImage = MapImageFactory.fromResource(context.getResources(), R.drawable.here_car);
MapMarker mapMarker = new MapMarker(geoCoordinates, mapImage);

mapView.getMapScene().addMapMarker(mapMarker);

val mapImage = MapImageFactory.fromResource(context.getResources(), R.drawable.here_car)
val mapMarker = MapMarker(geoCoordinates, mapImage)

mapView.mapScene.addMapMarker(mapMarker)

mapView.getMapScene().removeMapMarker(mapMarker);

mapView.getMapScene().removeMapMarker(mapMarker)

mapView.getMapScene().removeMapMarkers(mapMarkerList);

mapView.getMapScene().removeMapMarkers(mapMarkerList)

// Optionally, enable a fade in-out animation.
mapMarker.setFadeDuration(Duration.ofSeconds(3));

// Optionally, enable a fade in-out animation.
mapMarker.setFadeDuration(Duration.ofSeconds(3))

MapImage mapImage = MapImageFactory.fromResource(context.getResources(), R.drawable.poi);

// The bottom, middle position should point to the location.
// By default, the anchor point is set to 0.5, 0.5.
Anchor2D anchor2D = new Anchor2D(0.5F, 1);
MapMarker mapMarker = new MapMarker(geoCoordinates, mapImage, anchor2D);

mapView.getMapScene().addMapMarker(mapMarker);

val mapImage = MapImageFactory.fromResource(context.getResources(), R.drawable.poi)

// The bottom, middle position should point to the location.
// By default, the anchor point is set to 0.5, 0.5.
val anchor2D = Anchor2D(0.5, 1.0)
val mapMarker = MapMarker(geoCoordinates, mapImage, anchor2D)

mapView.mapScene.addMapMarker(mapMarker)

String fontFileName = "SimpleSans.ttf";
AssetsManager assetManager = new AssetsManager(mapView.getMapContext());

// "SimpleSans" specifies the font name to be referenced wherever required.
assetManager.registerFont("SimpleSans", fontFileName);

val fontFileName = "SimpleSans.ttf"
val assetManager = AssetsManager(mapView.mapContext)

// "SimpleSans" specifies the font name to be referenced wherever required.
assetManager.registerFont("SimpleSans", fontFileName)

MapMarker.TextStyle textStyleCurrent = mapMarker.getTextStyle();
MapMarker.TextStyle textStyleNew = mapMarker.getTextStyle();
double textSizeInPixels = 30;
double textOutlineSizeInPixels = 5;

// Placement priority is based on order. It is only effective when
// overlap is disallowed. The below setting will show the text
// at the bottom of the marker, but when the marker or the text overlaps
// then the text will swap to the top before the marker disappears completely.
// Note: By default, markers do not disappear when they overlap.
List<MapMarker.TextStyle.Placement> placements = new ArrayList<>();
placements.add(MapMarker.TextStyle.Placement.BOTTOM);
placements.add(MapMarker.TextStyle.Placement.TOP);
mapMarker.setOverlapAllowed(false);

try {
    textStyleNew = new MapMarker.TextStyle(
            textSizeInPixels,
            textStyleCurrent.getTextColor(),
            textOutlineSizeInPixels,
            textStyleCurrent.getTextOutlineColor(),
            placements,
            "SimpleSans"
            );
} catch (MapMarker.TextStyle.InstantiationException e) {
    // An error code will indicate what went wrong, for example, when negative values are set for text size.
    Log.e("TextStyle", "Error code: " + e.error.name());
}

mapMarker.setText("Hello Text");
mapMarker.setTextStyle(textStyleNew);

val textStyleCurrent: MapMarker.TextStyle = mapMarker.getTextStyle()
var textStyleNew: MapMarker.TextStyle = mapMarker.getTextStyle()
val textSizeInPixels = 30.0
val textOutlineSizeInPixels = 5.0

// Placement priority is based on order. It is only effective when
// overlap is disallowed. The below setting will show the text
// at the bottom of the marker, but when the marker or the text overlaps
// then the text will swap to the top before the marker disappears completely.
// Note: By default, markers do not disappear when they overlap.
val placements: MutableList<Placement> = ArrayList()
placements.add(Placement.BOTTOM)
placements.add(Placement.TOP)
mapMarker.setOverlapAllowed(false)

try {
    textStyleNew = MapMarker.TextStyle(
        textSizeInPixels,
        textStyleCurrent.textColor,
        textOutlineSizeInPixels,
        textStyleCurrent.textOutlineColor,
        placements,
        "SimpleSans"
    )
} catch (e: MapMarker.TextStyle.InstantiationException) {
    // An error code will indicate what went wrong, for example, when negative values are set for text size.
    Log.e("TextStyle", "Error code: " + e.error.name)
}

mapMarker.setText("Hello Text")
mapMarker.setTextStyle(textStyleNew)

private void setTapGestureHandler() {
    mapView.getGestures().setTapListener(new TapListener() {
        @Override
        public void onTap(@NonNull Point2D touchPoint) {
            pickMapMarker(touchPoint);
        }
    });
}

private void pickMapMarker(final Point2D touchPoint) {
    Point2D originInPixels = new Point2D(touchPoint.x, touchPoint.y);
    Size2D sizeInPixels = new Size2D(1, 1);
    Rectangle2D rectangle = new Rectangle2D(originInPixels, sizeInPixels);

    // Creates a list of map content type from which the results will be picked.
    // The content type values can be MAP_CONTENT, MAP_ITEMS and CUSTOM_LAYER_DATA.
    ArrayList<MapScene.MapPickFilter.ContentType> contentTypesToPickFrom = new ArrayList<>();

    // MAP_CONTENT is used when picking embedded carto POIs, traffic incidents, vehicle restriction etc.
    // MAP_ITEMS is used when picking map items such as MapMarker, MapPolyline, MapPolygon etc.
    // Currently we need map markers so adding the MAP_ITEMS filter.
    contentTypesToPickFrom.add(MapScene.MapPickFilter.ContentType.MAP_ITEMS);
    MapScene.MapPickFilter filter = new MapScene.MapPickFilter(contentTypesToPickFrom);

    // If you do not want to specify any filter you can pass filter as NULL and all of the pickable contents will be picked.
    mapView.pick(filter, rectangle, new MapViewBase.MapPickCallback() {
        @Override
        public void onPickMap(@Nullable MapPickResult mapPickResult) {
            if (mapPickResult == null) {
                // An error occurred while performing the pick operation.
                return;
            }
            PickMapItemsResult pickMapItemsResult = mapPickResult.getMapItems();

            // Note that 3D map markers can't be picked yet. Only marker, polygon and polyline map items are pickable.
            List<MapMarker> mapMarkerList = pickMapItemsResult.getMarkers();
            int listSize = mapMarkerList.size();
            if (listSize == 0) {
                return;
            }
            MapMarker topmostMapMarker = mapMarkerList.get(0);

            showDialog("Map marker picked:", "Location: " +
                    topmostMapMarker.getCoordinates().latitude + ", " +
                    topmostMapMarker.getCoordinates().longitude);
        }
    });
}

private fun setTapGestureHandler() {
    mapView.gestures.tapListener = TapListener { touchPoint -> pickMapMarker(touchPoint) }
}

private fun pickMapMarker(touchPoint: Point2D) {
    val originInPixels = Point2D(touchPoint.x, touchPoint.y)
    val sizeInPixels = Size2D(1.0, 1.0)
    val rectangle = Rectangle2D(originInPixels, sizeInPixels)

    // Creates a list of map content type from which the results will be picked.
    // The content type values can be MAP_CONTENT, MAP_ITEMS and CUSTOM_LAYER_DATA.
    val contentTypesToPickFrom = ArrayList<MapScene.MapPickFilter.ContentType>()

    // MAP_CONTENT is used when picking embedded carto POIs, traffic incidents, vehicle restriction etc.
    // MAP_ITEMS is used when picking map items such as MapMarker, MapPolyline, MapPolygon etc.
    // Currently we need map markers so adding the MAP_ITEMS filter.
    contentTypesToPickFrom.add(MapScene.MapPickFilter.ContentType.MAP_ITEMS)
    val filter = MapScene.MapPickFilter(contentTypesToPickFrom)

    // If you do not want to specify any filter you can pass filter as NULL and all of the pickable contents will be picked.
    mapView.pick(filter, rectangle, MapViewBase.MapPickCallback { mapPickResult ->
        if (mapPickResult == null) {
            // An error occurred while performing the pick operation.
            return@MapPickCallback
        }
        val pickMapItemsResult = mapPickResult.mapItems

        // Note that MapMarker items contained in a cluster are not part of pickMapItemsResult.getMarkers().
        handlePickedMapMarkerClusters(pickMapItemsResult)

        // Note that 3D map markers can't be picked yet. Only marker, polygon and polyline map items are pickable.
        val mapMarkerList = pickMapItemsResult!!.markers
        val listSize = mapMarkerList.size
        if (listSize == 0) {
            return@MapPickCallback
        }
        val topmostMapMarker = mapMarkerList[0]

        val metadata: Metadata? = topmostMapMarker.metadata
        if (metadata != null) {
            var message: String? = "No message found."
            val string: String? = metadata.getString("key_poi")
            if (string != null) {
                message = string
            }

            val stringMarkerText: String? = metadata.getString("key_poi_text")
            if (stringMarkerText != null) {
                // You can update text for a marker on-the-fly.
                topmostMapMarker.text = "Marker was picked."
                message = stringMarkerText
            }

            if (message != null) {
                showDialog("Map marker picked", message)
            }
            return@MapPickCallback
        }
        showDialog(
            "Map marker picked:", "Location: " +
                    topmostMapMarker.coordinates.latitude + ", " +
                    topmostMapMarker.coordinates.longitude
        )
    })
}

Metadata metadata = new Metadata();
metadata.setString("key_poi", "This is a POI.");
mapMarker.setMetadata(metadata);

val metadata = Metadata()
metadata.setString("key_poi", "This is a POI.")
mapMarker.metadata = metadata

Metadata metadata = topmostMapMarker.getMetadata();
if (metadata != null) {
    String message = "No message found.";
    String string = metadata.getString("key_poi");
    if (string != null) {
        message = string;
    }
    showDialog("Map Marker picked", message);
    return;
}

val metadata: Metadata = topmostMapMarker.getMetadata()
if (metadata != null) {
    var message: String? = "No message found."
    val string = metadata.getString("key_poi")
    if (string != null) {
        message = string
    }
    showDialog("Map Marker picked", message!!)
    return
}

public void showMapMarkerCluster() {
    MapImage clusterMapImage = MapImageFactory.fromResource(context.getResources(), R.drawable.green_square);

    // Defines a text that indicates how many markers are included in the cluster.
    MapMarkerCluster.CounterStyle counterStyle = new MapMarkerCluster.CounterStyle();
    counterStyle.textColor = new Color(0, 0, 0, 1); // Black
    counterStyle.fontSize = 40;
    counterStyle.maxCountNumber = 9;
    counterStyle.aboveMaxText = "+9";

    MapMarkerCluster mapMarkerCluster = new MapMarkerCluster(
            new MapMarkerCluster.ImageStyle(clusterMapImage), counterStyle);
    mapView.getMapScene().addMapMarkerCluster(mapMarkerCluster);
    mapMarkerClusterList.add(mapMarkerCluster);

    for (int i = 0; i < 10; i++) {
        mapMarkerCluster.addMapMarker(createRandomMapMarkerInViewport("" + i));
    }
}

fun showMapMarkerCluster() {
    val clusterMapImage = MapImageFactory.fromResource(context.resources, R.drawable.green_square)

    // Defines a text that indicates how many markers are included in the cluster.
    val counterStyle = MapMarkerCluster.CounterStyle()
    counterStyle.textColor = Color(0f, 0f, 0f, 1f) // Black
    counterStyle.fontSize = 40.0
    counterStyle.maxCountNumber = 9
    counterStyle.aboveMaxText = "+9"

    val mapMarkerCluster = MapMarkerCluster(
        MapMarkerCluster.ImageStyle(clusterMapImage), counterStyle
    )
    mapView.mapScene.addMapMarkerCluster(mapMarkerCluster)
    mapMarkerClusterList.add(mapMarkerCluster)

    for (i in 0..9) {
        mapMarkerCluster.addMapMarker(createRandomMapMarkerInViewport("" + i))
    }
}

mapView.getMapScene().removeMapMarkerCluster(mapMarkerCluster);

mapView.getMapScene().removeMapMarkerCluster(mapMarkerCluster)

private void handlePickedMapMarkerClusters(PickMapItemsResult pickMapItemsResult) {
    List<MapMarkerCluster.Grouping> groupingList = pickMapItemsResult.getClusteredMarkers();
    if (groupingList.size() == 0) {
        return;
    }

    MapMarkerCluster.Grouping topmostGrouping = groupingList.get(0);
    int clusterSize = topmostGrouping.markers.size();
    if (clusterSize == 0) {
        // This cluster does not contain any MapMarker items.
        return;
    }
    if (clusterSize == 1) {
        showDialog("Map marker picked",
                "This MapMarker belongs to a cluster. Metadata: " + getClusterMetadata(topmostGrouping.markers.get(0)));
    } else {
        String metadata = "";
        for (MapMarker mapMarker: topmostGrouping.markers) {
            metadata += getClusterMetadata(mapMarker);
            metadata += " ";
        }
        showDialog("Map marker cluster picked",
                "Number of contained markers in this cluster: " + clusterSize + ". " +
                "Contained Metadata: " + metadata + ". " +
                "Total number of markers in this MapMarkerCluster: " + topmostGrouping.parent.getMarkers().size());
    }
}

private String getClusterMetadata(MapMarker mapMarker) {
    Metadata metadata = mapMarker.getMetadata();
    String message = "No metadata.";
    if (metadata != null) {
        String string = metadata.getString("key_cluster");
        if (string != null) {
            message = string;
        }
    }
    return message;
}

private fun handlePickedMapMarkerClusters(pickMapItemsResult: PickMapItemsResult?) {
    val groupingList = pickMapItemsResult!!.clusteredMarkers
    if (groupingList.size == 0) {
        return
    }

    val topmostGrouping = groupingList[0]
    val clusterSize = topmostGrouping.markers.size
    if (clusterSize == 0) {
        // This cluster does not contain any MapMarker items.
        return
    }
    if (clusterSize == 1) {
        showDialog(
            "Map marker picked",
            "This MapMarker belongs to a cluster. Metadata: " + getClusterMetadata(topmostGrouping.markers[0])
        )
    } else {
        var metadata = ""
        for (mapMarker in topmostGrouping.markers) {
            metadata += getClusterMetadata(mapMarker)
            metadata += " "
        }
        showDialog(
            "Map marker cluster picked",
            "Number of contained markers in this cluster: " + clusterSize + ". " +
                    "Contained Metadata: " + metadata + ". " +
                    "Total number of markers in this MapMarkerCluster: " + topmostGrouping.parent.markers.size
        )
    }
}

private fun getClusterMetadata(mapMarker: MapMarker): String {
    val metadata: Metadata? = mapMarker.metadata
    var message = "No metadata."
    if (metadata != null) {
        val string: String? = metadata.getString("key_cluster")
        if (string != null) {
            message = string
        }
    }
    return message
}

private void checkIfFileExistsInAssetsFolder(String fileName) {
    AssetManager assetManager = context.getAssets();
    try {
        assetManager.open(fileName);
    } catch (IOException e) {
        Log.e("MapMarkerExample", "Error: File not found!");
    }
}

private fun checkIfFileExistsInAssetsFolder(fileName: String) {
    val assetManager = context.assets
    try {
        assetManager.open(fileName)
    } catch (e: IOException) {
        Log.e("MapItemsExample", "Error: File not found!")
    }
}

String geometryFile = "obstacle.obj";
String textureFile = "obstacle_texture.png";
checkIfFileExistsInAssetsFolder(geometryFile);
checkIfFileExistsInAssetsFolder(textureFile);

MapMarker3DModel mapMarker3DModel = new MapMarker3DModel(geometryFile, textureFile);
MapMarker3D mapMarker3D = new MapMarker3D(geoCoordinates, mapMarker3DModel);
mapMarker3D.setScale(6);
mapMarker3D.setDepthCheckEnabled(true);

mapView.getMapScene().addMapMarker3d(mapMarker3D);

val geometryFile = "obstacle.obj"
val textureFile = "obstacle_texture.png"
checkIfFileExistsInAssetsFolder(geometryFile)
checkIfFileExistsInAssetsFolder(textureFile)

val mapMarker3DModel = MapMarker3DModel(geometryFile, textureFile)
val mapMarker3D = MapMarker3D(geoCoordinates, mapMarker3DModel)
mapMarker3D.scale = 6.0
mapMarker3D.isDepthCheckEnabled = true

mapView.mapScene.addMapMarker3d(mapMarker3D)

MapImage mapImage = MapImageFactory.fromResource(context.getResources(), R.drawable.poi);

// The default scale factor of the map marker is 1.0. For a scale of 2, the map marker becomes 2x larger.
// For a scale of 0.5, the map marker shrinks to half of its original size.
double scaleFactor = 1.0;

// With DENSITY_INDEPENDENT_PIXELS the map marker will have a constant size on the screen regardless if the map is zoomed in or out.
MapMarker3D mapMarker3D = new MapMarker3D(geoCoordinates, mapImage, scaleFactor, RenderSize.Unit.DENSITY_INDEPENDENT_PIXELS);

mapView.getMapScene().addMapMarker3d(mapMarker3D);

val mapImage = MapImageFactory.fromResource(context.resources, R.drawable.poi)

// The default scale factor of the map marker is 1.0. For a scale of 2, the map marker becomes 2x larger.
// For a scale of 0.5, the map marker shrinks to half of its original size.
val scaleFactor = 1.0

// With DENSITY_INDEPENDENT_PIXELS the map marker will have a constant size on the screen regardless if the map is zoomed in or out.
val mapMarker3D = MapMarker3D(geoCoordinates, mapImage, scaleFactor, RenderSize.Unit.DENSITY_INDEPENDENT_PIXELS)

mapView.mapScene.addMapMarker3d(mapMarker3D)

String geometryFile = "plane.obj";
String textureFile = "poi_texture.png";
checkIfFileExistsInAssetsFolder(geometryFile);
checkIfFileExistsInAssetsFolder(textureFile);

MapMarker3DModel mapMarker3DModel = new MapMarker3DModel(geometryFile, textureFile);
MapMarker3D mapMarker3D = new MapMarker3D(geoCoordinates, mapMarker3DModel);
mapMarker3D.setScale(60);

mapView.getMapScene().addMapMarker3d(mapMarker3D);

val geometryFile = "plane.obj"
val textureFile = "poi_texture.png"
checkIfFileExistsInAssetsFolder(geometryFile)
checkIfFileExistsInAssetsFolder(textureFile)

val mapMarker3DModel = MapMarker3DModel(geometryFile, textureFile)
val mapMarker3D = MapMarker3D(geoCoordinates, mapMarker3DModel)
mapMarker3D.scale = 60.0

mapView.mapScene.addMapMarker3d(mapMarker3D)

private void addLocationIndicator(GeoCoordinates geoCoordinates,
                                  LocationIndicator.IndicatorStyle indicatorStyle) {
    LocationIndicator locationIndicator = new LocationIndicator();
    locationIndicator.setLocationIndicatorStyle(indicatorStyle);

    // A LocationIndicator is intended to mark the user's current location,
    // including a bearing direction.
    // For testing purposes, we create a Location object. Usually, you may want to get this from
    // a GPS sensor instead.
    Location location = new Location(geoCoordinates);
    location.time = new Date();
    location.bearingInDegrees = getRandom(0, 360);

    locationIndicator.updateLocation(location);

    // Show the indicator on the map view.
    locationIndicator.enable(mapView);
}

private fun addLocationIndicator(
  geoCoordinates: GeoCoordinates,
  indicatorStyle: LocationIndicator.IndicatorStyle
) {
  val locationIndicator = LocationIndicator()
  locationIndicator.locationIndicatorStyle = indicatorStyle

  // A LocationIndicator is intended to mark the user's current location,
  // including a bearing direction.
  val location: Location = Location(geoCoordinates)
  location.time = Date()
  location.bearingInDegrees = getRandom(0.0, 360.0)

  locationIndicator.updateLocation(location)

  // Show the indicator on the map view.
  locationIndicator.enable(mapView)

  locationIndicatorList.add(locationIndicator)
}

boolean isActive = locationIndicator.isActive();
// Toggle between active / inactive state.
locationIndicator.setActive(!isActive);

val isActive: Boolean = locationIndicator.isActive()
// Toggle between active / inactive state.
locationIndicator.setActive(!isActive)

locationIndicator.setHaloColor(IndicatorStyle.PEDESTRIAN, new Color(255F, 255F, 0F, 0.30F));

locationIndicator.setHaloColor(IndicatorStyle.PEDESTRIAN, Color(255f, 255f, 0f, 0.30f))

// Remove locationIndicator from map view.
locationIndicator.disable();

// Remove locationIndicator from map view.
locationIndicator.disable()

TextView textView = new TextView(context);
textView.setTextColor(Color.parseColor("#FFFFFF"));
textView.setText("Centered ViewPin");

LinearLayout linearLayout = new LinearLayout(context);
linearLayout.setBackgroundResource(R.color.colorAccent);
linearLayout.setPadding(10, 10, 10, 10);
linearLayout.addView(textView);

val textView = TextView(context)
textView.setTextColor(Color.parseColor("#FFFFFF"))
textView.text = "Centered ViewPin"

val linearLayout = LinearLayout(context)
linearLayout.setBackgroundResource(R.color.colorAccent)
linearLayout.setPadding(10, 10, 10, 10)
linearLayout.addView(textView)

ViewPin viewPin = mapView.pinView(linearLayout, geoCoordinates);

val viewPin = mapView.pinView(linearLayout, geoCoordinates)

linearLayout.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Log.i(TAG, "Tapped on MapViewPin");
    }
});

linearLayout.setOnClickListener(View.OnClickListener { Log.i(TAG, "Tapped on MapViewPin") })

mapView.unpinView(view);

mapView.unpinView(view)

List<ViewPin> viewPins = mapView.getViewPins();

val viewPins: List<ViewPin> = mapView.viewPins

viewPin.setAnchorPoint(new Anchor2D(0.5F, 1));

viewPin.setAnchorPoint(Anchor2D(0.5, 1.0))

// Create the polyline.
mapPolyline = createPolyline();

// Configure the progress color. Currently, cyan color is being used.
Color progressColor = new Color(0f, 1f, 1f, 0.5f);
mapPolyline.setProgressColor(progressColor);

// Set the progress value, ranging from 0 to 1. For example, 0.40 represents 40% progress.
mapPolyline.setProgress(0.40);

// Define the gradient length using MapMeasureDependentRenderSize.
MapMeasureDependentRenderSize gradientLength;
try {
    double widthInPixels = 20.0;
    gradientLength = new MapMeasureDependentRenderSize(RenderSize.Unit.PIXELS, widthInPixels);
} catch (MapMeasureDependentRenderSize.InstantiationException e) {
    Log.e("MapMeasureDependentRenderSize Exception:", e.error.name());
    return;
}

// Set the maximum gradient length between 'lineColor' and 'progressColor' in zoom-level-dependent pixels.
mapPolyline.setProgressGradientLength(gradientLength);
mapScene.addMapPolyline(mapPolyline);

// Create the polyline.
mapPolyline = createPolyline()

mapPolyline?.apply {
    // Configure the progress color. Currently, cyan is being used.
    progressColor = Color(0f, 1f, 1f, 0.5f)

    // Set the progress value, ranging from 0 to 1. For example, 0.40 represents 40% progress.
    progress = 0.40
}

// Define the gradient length using MapMeasureDependentRenderSize.
val gradientLength: MapMeasureDependentRenderSize
try {
    val widthInPixels = 20.0
    gradientLength = MapMeasureDependentRenderSize(RenderSize.Unit.PIXELS, widthInPixels)
} catch (e: MapMeasureDependentRenderSize.InstantiationException) {
    Log.e("MapMeasureDependentRenderSize Exception:", e.error.name)
    return
}

// Set the maximum gradient length between 'lineColor' and 'progressColor' in zoom-level-dependent pixels.
mapPolyline?.let {
    it.progressGradientLength = gradientLength
    mapScene?.addMapPolyline(it)
}