private void getAddressForCoordinates(GeoCoordinates geoCoordinates) {
  SearchOptions reverseGeocodingOptions = new SearchOptions();
  reverseGeocodingOptions.languageCode = LanguageCode.EN_GB;
  reverseGeocodingOptions.maxItems = 1;

    searchEngine.searchByCoordinates(geoCoordinates, reverseGeocodingOptions, addressSearchCallback);
}

private final SearchCallback addressSearchCallback = new SearchCallback() {
    @Override
    public void onSearchCompleted(@Nullable SearchError searchError, @Nullable List<Place> list) {
        if (searchError != null) {
            showDialog("Reverse geocoding", "Error: " + searchError.toString());
            return;
        }

        // If error is null, list is guaranteed to be not empty.
        showDialog("Reverse geocoded address:", list.get(0).getAddress().addressText);
    }
};

private fun getAddressForCoordinates(geoCoordinates: GeoCoordinates) {
    val reverseGeocodingOptions = SearchOptions()
    reverseGeocodingOptions.languageCode = LanguageCode.EN_GB
    reverseGeocodingOptions.maxItems = 1

    searchEngine!!.searchByCoordinates(
        geoCoordinates,
        reverseGeocodingOptions,
        addressSearchCallback
    )
}

private val addressSearchCallback =
    SearchCallback { searchError, list ->
        if (searchError != null) {
            showDialog("Reverse geocoding", "Error: $searchError")
            return@SearchCallback
        }
        // If error is null, list is guaranteed to be not empty.
        showDialog("Reverse geocoded address:", list!![0].address.addressText)
    }

// The geoCoordinates act as a reference location to prioritize the search results.
// This helps the `SearchEngine` return addresses that are more relevant and closer to the user’s
// current location instead of global or less relevant matches.
AddressQuery query = new AddressQuery(queryString, geoCoordinates);

SearchOptions options = new SearchOptions();
options.languageCode = LanguageCode.DE_DE;
options.maxItems = 30;

searchEngine.searchByAddress(query, options, geocodeAddressSearchCallback);

...

private final SearchCallback geocodeAddressSearchCallback = new SearchCallback() {
    @Override
    public void onSearchCompleted(SearchError searchError, List<Place> list) {
        if (searchError != null) {
            showDialog("Geocoding", "Error: " + searchError.toString());
            return;
        }

        for (Place geocodingResult : list) {
            //...
        }

        showDialog("Geocoding result","Size: " + list.size());
    }
};

// The geoCoordinates act as a reference location to prioritize the search results.
// This helps the `SearchEngine` return addresses that are more relevant and closer to the user’s
// current location instead of global or less relevant matches.
val query = AddressQuery(queryString, geoCoordinates)

val options = SearchOptions()
options.languageCode = LanguageCode.DE_DE
options.maxItems = 30

searchEngine!!.searchByAddress(query, options, geocodeAddressSearchCallback)

...

private val geocodeAddressSearchCallback =
    SearchCallback { searchError, list ->
        if (searchError != null) {
            showDialog("Geocoding", "Error: $searchError")
            return@SearchCallback
        }
        for (geocodingResult in list!!) {
            // Note: getGeoCoordinates() may return null only for Suggestions.
            val geoCoordinates = geocodingResult.geoCoordinates
            val address = geocodingResult.address
            val locationDetails = (address.addressText
                    + ". GeoCoordinates: " + geoCoordinates!!.latitude
                    + ", " + geoCoordinates.longitude)

            Log.d(
                LOG_TAG,
                "GeocodingResult: $locationDetails"
            )
            addPoiMapMarker(geoCoordinates)
        }
        showDialog("Geocoding result", "Size: " + list.size)
    }

for (Place geocodingResult : list) {
    // Note: getGeoCoordinates() may return null only for Suggestions.
    GeoCoordinates geoCoordinates = geocodingResult.getGeoCoordinates();
    Address address = geocodingResult.getAddress();
    String locationDetails = address.addressText
            + ". GeoCoordinates: " + geoCoordinates.latitude
            + ", " + geoCoordinates.longitude;
    //...
}

for (geocodingResult in list!!) {
    // Note: getGeoCoordinates() may return null only for Suggestions.
    val geoCoordinates = geocodingResult.geoCoordinates
    val address = geocodingResult.address
    val locationDetails = (address.addressText
            + ". GeoCoordinates: " + geoCoordinates!!.latitude
            + ", " + geoCoordinates.longitude)
    //...
}

GeoCoordinates centerGeoCoordinates = getMapViewCenter();

SearchOptions searchOptions = new SearchOptions();
searchOptions.languageCode = LanguageCode.EN_US;
searchOptions.maxItems = 5;

TextQuery.Area queryArea = new TextQuery.Area(centerGeoCoordinates);

// Simulate a user typing a search term.
searchEngine.suggestByText(
        new TextQuery("p", // User typed "p".
                queryArea),
        searchOptions,
        autosuggestCallback);

searchEngine.suggestByText(
        new TextQuery("pi", // User typed "pi".
                queryArea),
        searchOptions,
        autosuggestCallback);

searchEngine.suggestByText(
        new TextQuery("piz", // User typed "piz".
                queryArea),
        searchOptions,
        autosuggestCallback);

val centerGeoCoordinates = mapViewCenter

val searchOptions = SearchOptions()
searchOptions.languageCode = LanguageCode.EN_US
searchOptions.maxItems = 5

val queryArea = TextQuery.Area(centerGeoCoordinates)

// Simulate a user typing a search term.
searchEngine!!.suggestByText(
    TextQuery(
        "p",  // User typed "p".
        queryArea
    ),
    searchOptions,
    autosuggestCallback
)

searchEngine!!.suggestByText(
    TextQuery(
        "pi",  // User typed "pi".
        queryArea
    ),
    searchOptions,
    autosuggestCallback
)

searchEngine!!.suggestByText(
    TextQuery(
        "piz",  // User typed "piz".
        queryArea
    ),
    searchOptions,
    autosuggestCallback
)

private final SuggestCallback autosuggestCallback = new SuggestCallback() {
    @Override
    public void onSuggestCompleted(@Nullable SearchError searchError, @Nullable List<Suggestion> list) {
        if (searchError != null) {
            Log.d(LOG_TAG, "Autosuggest Error: " + searchError.name());
            return;
        }

        // If error is null, list is guaranteed to be not empty.
        Log.d(LOG_TAG, "Autosuggest results: " + list.size());

        for (Suggestion autosuggestResult : list) {
            String addressText = "Not a place.";
            Place place = autosuggestResult.getPlace();
            if (place != null) {
                addressText = place.getAddress().addressText;
            }

            Log.d(LOG_TAG, "Autosuggest result: " + autosuggestResult.getTitle() +
                    " addressText: " + addressText);
        }
    }
};

private val autosuggestCallback =
    SuggestCallback { searchError, list ->
        if (searchError != null) {
            Log.d(LOG_TAG, "Autosuggest Error: " + searchError.name)
            return@SuggestCallback
        }
        // If error is null, list is guaranteed to be not empty.
        Log.d(LOG_TAG, "Autosuggest results: " + list!!.size)
        for (autosuggestResult in list) {
            var addressText = "Not a place."
            val place = autosuggestResult.place
            if (place != null) {
                addressText = place.address.addressText
            }

            Log.d(
                LOG_TAG, "Autosuggest result: " + autosuggestResult.title +
                        " addressText: " + addressText
            )
        }
    }

private void searchForCategories() {
    List<PlaceCategory> categoryList = new ArrayList<>();
    categoryList.add(new PlaceCategory(PlaceCategory.EAT_AND_DRINK));
    categoryList.add(new PlaceCategory(PlaceCategory.SHOPPING_ELECTRONICS));

    CategoryQuery.Area queryArea = new CategoryQuery.Area(new GeoCoordinates(52.520798, 13.409408));
    CategoryQuery categoryQuery = new CategoryQuery(categoryList, queryArea);

    SearchOptions searchOptions = new SearchOptions();
    searchOptions.languageCode = LanguageCode.EN_US;
    searchOptions.maxItems = 30;

    searchEngine.searchByCategory(categoryQuery, searchOptions, new SearchCallback() {
        @Override
        public void onSearchCompleted(SearchError searchError, List<Place> list) {
            if (searchError != null) {
                infoTextview.setText("Search Error: " + searchError.toString());
                return;
            }

            // If error is null, list is guaranteed to be not empty.
            String numberOfResults = "Search results: " + list.size() + ". See log for details.";
            infoTextview.setText(numberOfResults);

            for (Place searchResult : list) {
                String addressText = searchResult.getAddress().addressText;
                Log.d(TAG, addressText);
            }
        }
    });
}

PlaceChain placeChain = new PlaceChain("1566");
List<PlaceChain> includeChains = new ArrayList<>();
includeChains.add(placeChain);
categoryQuery.includeChains = includeChains;

TextQuery textQuery = TextQuery("restaurants", route.getBoundingBox())

// Perform a search for charging stations along the found route.
private void searchAlongARoute(Route route) {
    // We specify here that we only want to include results
    // within a max distance of xx meters from any point of the route.
    int halfWidthInMeters = 200;
    GeoCorridor routeCorridor = new GeoCorridor(route.getGeometry().vertices, halfWidthInMeters);
    PlaceCategory placeCategory = new PlaceCategory(PlaceCategory.BUSINESS_AND_SERVICES_EV_CHARGING_STATION);
    CategoryQuery.Area categoryQueryArea = new CategoryQuery.Area(routeCorridor, mapView.getCamera().getState().targetCoordinates);
    CategoryQuery categoryQuery = new CategoryQuery(placeCategory, categoryQueryArea);

    SearchOptions searchOptions = new SearchOptions();
    searchOptions.languageCode = LanguageCode.EN_US;
    searchOptions.maxItems = 30;

    searchEngine.searchByCategory(categoryQuery, searchOptions, new SearchCallback() {
        @Override
        public void onSearchCompleted(SearchError searchError, List<Place> items) {
            if (searchError != null) {
                Log.d("Search", "No charging stations found along the route. Error: " + searchError);
                return;
            }

            // If error is nil, it is guaranteed that the items will not be nil.
            Log.d("Search","Search along route found " + items.size() + " charging stations:");
            for (Place place : items) {
                // ...
            }
        }
    });
}

// Enable fetching online availability details for EV charging stations.
// It allows retrieving additional details, such as whether a charging station is currently occupied.
// Check the API Reference for more details.
private void enableEVChargingStationDetails() {
    // Fetching additional charging stations details requires a custom option call.
    SearchError error = searchEngine.setCustomOption("browse.show", "ev");
    if (error != null) {
        showDialog("Charging station",
                "Failed to enableEVChargingStationDetails.");
    } else {
        Log.d("ChargingStation", "EV charging station availability enabled successfully.");
    }
}

private void searchAlongARoute(Route route) {
    // We specify here that we only want to include results
    // within a max distance of xx meters from any point of the route.
    int halfWidthInMeters = 200;
    GeoCorridor routeCorridor = new GeoCorridor(route.getGeometry().vertices, halfWidthInMeters);
    PlaceCategory placeCategory = new PlaceCategory(PlaceCategory.BUSINESS_AND_SERVICES_EV_CHARGING_STATION);
    CategoryQuery.Area categoryQueryArea = new CategoryQuery.Area(routeCorridor, mapView.getCamera().getState().targetCoordinates);
    CategoryQuery categoryQuery = new CategoryQuery(placeCategory, categoryQueryArea);

    SearchOptions searchOptions = new SearchOptions();
    searchOptions.languageCode = LanguageCode.EN_US;
    searchOptions.maxItems = 30;

    enableEVChargingStationDetails();

    searchEngine.searchByCategory(categoryQuery, searchOptions, new SearchCallback() {
        @Override
        public void onSearchCompleted(SearchError searchError, List<Place> items) {
            if (searchError != null) {
                Log.d("Search", "No charging stations found along the route. Error: " + searchError);
                return;
            }
            // If error is nil, it is guaranteed that the items will not be nil.
            Log.d("Search","Search along route found " + items.size() + " charging stations:");
            for (Place place : items) {
                Details details = place.getDetails();
                Metadata metadata = getMetadataForEVChargingPools(details);
                boolean foundExistingChargingStation = false;
                for (MapMarker mapMarker : mapMarkers) {
                    if (mapMarker.getMetadata() != null) {
                        String id = mapMarker.getMetadata().getString(REQUIRED_CHARGING_METADATA_KEY);
                        if (id != null && id.equalsIgnoreCase(place.getId())) {
                            Log.d("Search", "Insert metdata to existing charging station: This charging station was already required to reach the destination (see red charging icon).");
                            mapMarker.setMetadata(metadata);
                            foundExistingChargingStation = true;
                            break;
                        }
                    }
                }

                if (!foundExistingChargingStation) {
                    addMapMarker(place.getGeoCoordinates(), R.drawable.charging, metadata);
                }
            }
        }
    });
}

private Metadata getMetadataForEVChargingPools(Details placeDetails) {
    Metadata metadata = new Metadata();
    if (placeDetails.evChargingPool != null) {
        for (EVChargingStation station : placeDetails.evChargingPool.chargingStations) {
            if (station.supplierName != null) {
                metadata.setString(SUPPLIER_NAME_METADATA_KEY, station.supplierName);
            }
            if (station.connectorCount != null) {
                metadata.setString(CONNECTOR_COUNT_METADATA_KEY, String.valueOf(station.connectorCount));
            }
            if (station.availableConnectorCount != null) {
                metadata.setString(AVAILABLE_CONNECTORS_METADATA_KEY, String.valueOf(station.availableConnectorCount));
            }
            if (station.occupiedConnectorCount != null) {
                metadata.setString(OCCUPIED_CONNECTORS_METADATA_KEY, String.valueOf(station.occupiedConnectorCount));
            }
            if (station.outOfServiceConnectorCount != null) {
                metadata.setString(OUT_OF_SERVICE_CONNECTORS_METADATA_KEY, String.valueOf(station.outOfServiceConnectorCount));
            }
            if (station.reservedConnectorCount != null) {
                metadata.setString(RESERVED_CONNECTORS_METADATA_KEY, String.valueOf(station.reservedConnectorCount));
            }
            if (station.lastUpdated != null) {
                metadata.setString(LAST_UPDATED_METADATA_KEY, String.valueOf(station.lastUpdated));
            }
        }
    }
    return metadata;
}