private void loadMapScene() {
    // Load a scene from the HERE SDK to render the map with a map scheme.
    mapView.getMapScene().loadScene(MapScheme.NORMAL_DAY, new MapScene.LoadSceneCallback() {
        @Override
        public void onLoadScene(@Nullable MapError mapError) {
            if (mapError == null) {
                double distanceInMeters = 1000 * 10;
                MapMeasure mapMeasureZoom = new MapMeasure(MapMeasure.Kind.DISTANCE_IN_METERS, distanceInMeters);
                mapView.getCamera().lookAt(
                        new GeoCoordinates(52.530932, 13.384915), mapMeasureZoom);
            } else {
                Log.d("loadMapScene()", "Loading map failed: mapError: " + mapError.name());
            }
        }
    });
}

private fun loadMapScene() {
    // Load a scene from the HERE SDK to render the map with a map scheme.
    mapView!!.mapScene.loadScene(MapScheme.NORMAL_DAY) { mapError ->
        if (mapError == null) {
            val distanceInMeters = (1000 * 10).toDouble()
            val mapMeasureZoom = MapMeasure(MapMeasure.Kind.DISTANCE_IN_METERS, distanceInMeters)
            mapView!!.camera.lookAt(
                GeoCoordinates(52.530932, 13.384915), mapMeasureZoom
            )
        } else {
            Log.d("loadMapScene()", "Loading map failed: mapError: " + mapError.name)
        }
    }
}

mapView.setOnReadyListener(new MapView.OnReadyListener() {
    @Override
    public void onMapViewReady() {
        // This will be called each time after this activity is resumed.
        // It will not be called before the first map scene was loaded.
        // Any code that requires map data may not work as expected until this event is received.
        Log.d(TAG, "HERE Rendering Engine attached.");
    }
});

mapView!!.setOnReadyListener { // This will be called each time after this activity is resumed.
    // It will not be called before the first map scene was loaded.
    // Any code that requires map data may not work as expected until this event is received.
    Log.d(TAG, "HERE Rendering Engine attached.")
}

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

private void pickMapContent(final Point2D touchPoint) {
    // You can also use a larger area to include multiple map icons.
    Rectangle2D rectangle2D = new Rectangle2D(touchPoint, new Size2D(50, 50));
    // 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 Carto POIs so adding the MAP_CONTENT filter.
    contentTypesToPickFrom.add(MapScene.MapPickFilter.ContentType.MAP_CONTENT);
    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, rectangle2D, mapPickResult -> {
        if (mapPickResult == null) {
            Log.e("onPickMapContent", "An error occurred while performing the pick operation.");
            return;
        }
        PickMapContentResult pickedContent = mapPickResult.getMapContent();
        handlePickedCartoPOIs(pickedContent.getPickedPlaces());
        handlePickedVehicleRestrictions(pickedContent.getVehicleRestrictions());
        // ... handle more content results when needed.
    });
}

private void handlePickedCartoPOIs(List<PickedPlace> cartoPOIList) {
    int listSize = cartoPOIList.size();
    if (listSize == 0) {
        return;
    }

    PickedPlace topmostPickedPlace = cartoPOIList.get(0);
    showDialog("Carto POI picked:", topmostPickedPlace.name + ", Location: " +
            topmostPickedPlace.coordinates.latitude + ", " +
            topmostPickedPlace.coordinates.longitude + ". " +
            "See log for more place details.");

    // Now you can use the SearchEngine or the OfflineSearchEngine, when available for your license,
    // to retrieve the Place object containing more details.
}

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

private fun pickMapContent(touchPoint: Point2D) {
    // You can also use a larger area to include multiple map icons.
    val rectangle2D = Rectangle2D(touchPoint, Size2D(50.0, 50.0))
    // 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<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 Carto POIs so adding the MAP_CONTENT filter.
    contentTypesToPickFrom.add(MapPickFilter.ContentType.MAP_CONTENT)
    val filter = 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, rectangle2D) { mapPickResult: MapPickResult? ->
        if (mapPickResult == null) {
            Log.e("onPickMapContent", "An error occurred while performing the pick operation.")
            return@pick
        }
        val pickedContent = mapPickResult.mapContent
        handlePickedCartoPOIs(pickedContent!!.pickedPlaces)
    }
}

private fun handlePickedCartoPOIs(cartoPOIList: List<PickedPlace>) {
    val listSize = cartoPOIList.size
    if (listSize == 0) {
        return
    }

    val topmostPickedPlace = cartoPOIList[0]
    showDialog(
        "Carto POI picked:", topmostPickedPlace.name + ", Location: " +
                topmostPickedPlace.coordinates.latitude + ", " +
                topmostPickedPlace.coordinates.longitude + ". " +
                "See log for more place details."
    )

    // Now you can use the SearchEngine or the OfflineSearchEngine, when available for your license,
    // to retrieve the Place object containing more details.
}

private void handlePickedVehicleRestrictions(List<PickMapContentResult.VehicleRestrictionResult> vehicleRestrictions) {
    int listSize = vehicleRestrictions.size();
    if (listSize == 0) {
        return;
    }

    PickMapContentResult.VehicleRestrictionResult topmostVehicleRestriction = vehicleRestrictions.get(0);
    createVehicleRestrictionIcon(topmostVehicleRestriction);
}

private fun handlePickedVehicleRestrictions(vehicleRestrictions: List<PickMapContentResult.VehicleRestrictionResult>) {
    if (vehicleRestrictions.isEmpty()) {
        return
    }

    val topmostVehicleRestriction = vehicleRestrictions.first()
    createVehicleRestrictionIcon(topmostVehicleRestriction)
}

private void createVehicleRestrictionIcon(PickMapContentResult.VehicleRestrictionResult vehicleRestrictionResult) {
IconProvider iconProvider = new IconProvider(mapView.getMapContext());

    IconProvider.IconCallback iconProviderCallback = new IconProvider.IconCallback() {
        @Override
        public void onCreateIconReply(@Nullable Bitmap bitmap, @Nullable String description, @Nullable IconProviderError iconProviderError) {
            if (iconProviderError == null) {
                // Now you can make use of the bitmap representation.
            }
        }
    };

    iconProvider.createVehicleRestrictionIcon(vehicleRestrictionResult, currentMapScheme, IconProviderAssetType.UI, new Size2D(), iconProviderCallback);
}

private fun createVehicleRestrictionIcon(vehicleRestrictionResult: PickMapContentResult.VehicleRestrictionResult) {
    val iconProviderCallback = object : IconCallback {
        override fun onCreateIconReply(
            bitmap: Bitmap?,
            description: String?,
            iconProviderError: IconProviderError?
        ) {
            if (iconProviderError == null) {
                // Now you can make use of the bitmap representation.
            }
        }
    }

    iconProvider.createVehicleRestrictionIcon(
        vehicleRestrictionResult,
        currentMapScheme,
        IconProviderAssetType.UI,
        Size2D(),
        iconProviderCallback
    )
}

// Note: You can change the visibility of individual embedded POI categories. This allows hiding specific categories of carto POIs.
List<String> categoryIds = new ArrayList<>();
categoryIds.add(PlaceCategory.EAT_AND_DRINK_RESTAURANT);
MapContentSettings.setPoiCategoriesVisibility(categoryIds, VisibilityState.HIDDEN);

// Note: You can change the visibility of individual embedded POI categories. This allows hiding specific categories of carto POIs.
val categoryIds = mutableListOf<String>()
categoryIds.add(PlaceCategory.EAT_AND_DRINK_RESTAURANT)
MapContentSettings.setPoiCategoriesVisibility(categoryIds, VisibilityState.HIDDEN)

<activity android:name=".YourActivity"
          android:configChanges="orientation">
    
</activity>

<com.here.sdk.mapview.MapView
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:id="@+id/map_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:projection="web_mercator">
    </com.here.sdk.mapview.MapView>

MapViewOptions mapViewOptions = new MapViewOptions();
mapViewOptions.setProjectionType(ProjectionType.WEB_MERCATOR);
MapView mapView = new MapView(this, mapViewOptions);

<com.here.sdk.mapview.MapView
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:id="@+id/map_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:projection="globe">
    </com.here.sdk.mapview.MapView>

MapViewOptions mapViewOptions = new MapViewOptions();
mapViewOptions.setProjectionType(ProjectionType.GLOBE);
MapView mapView = new MapView(this, mapViewOptions);

// Optionally, clear the cache, so that changing the options has an immediate effect.
SDKCache.fromEngine(SDKNativeEngine.getSharedInstance()).clearCache(error -> {
    if (error != null) {
      // ...
    }

    SDKOptions options = SDKNativeEngine.getSharedInstance().getOptions();
    options.politicalView = "ARG";
    SDKNativeEngine.getSharedInstance().dispose();

    // Now, initialize the HERE SDK again using the updated options.
});

// Optionally, clear the cache, so that changing the options has an immediate effect.
SDKCache.fromEngine(SDKNativeEngine.getSharedInstance()!!).clearCache { error: MapLoaderError? ->
    if (error != null) {
        // ...
    }
    val options = SDKNativeEngine.getSharedInstance()!!.options
    options.politicalView = "ARG"
    SDKNativeEngine.getSharedInstance()!!.dispose()

    // Now, initialize the HERE SDK again using the updated options.
}