検索を開始する

try {
    searchEngine = new SearchEngine();
} catch (InstantiationErrorException e) {
    throw new RuntimeException("Initialization of SearchEngine failed: " + e.error.name());
}

try {
    searchEngine = SearchEngine()
} catch (e: InstantiationErrorException) {
    throw RuntimeException("Initialization of SearchEngine failed: " + e.error.name)
}

public final class EVSearchExample {

    // Provides EVCP 3.0 enrichment; requires an additional EV Charging license beyond Navigate.
    private static final String LOG_TAG = "EVSearchExample";
    private final SearchEngine searchEngine;
    private final EVSearchEngine evSearchEngine;

    public EVSearchExample() throws InstantiationErrorException {
        searchEngine = new SearchEngine();
        evSearchEngine = new EVSearchEngine();
        searchEngine.setEVInterface(evSearchEngine);
    }

    // Works standalone for EV-only lookups or alongside SearchEngine to enrich generic results.
    public void searchEVChargingLocationsByPlaceIds(List<String> placeIds,
                                                    SearchOptions searchOptions) {
        EVSearchOptions evOptions = new EVSearchOptions();
        evOptions.additionalFeatures = Arrays.asList(
                EVChargingLocationFeature.ENERGY_MIX,
                EVChargingLocationFeature.OPENING_HOURS);

        // Direct EVSearchEngine call (can be used without SearchEngine involvement).
        evSearchEngine.setOptions(evOptions);
        evSearchEngine.search(placeIds, (evSearchError, locations) -> {
            if (evSearchError != null) {
                Log.d(LOG_TAG, "EV lookup failed: " + evSearchError);
                return;
            }
            for (EVChargingLocation location : locations) {
                Metadata metadata = new Metadata();
                metadata.setString("id", location.getID());
                metadata.setString("connectorGroups", String.valueOf(location.getConnectorGroups().size()));
                // Attach metadata to dedicated EV UI or map markers.
            }
        }, evOptions);

        // Optional: keep using SearchEngine so every place result surfaces evChargingLocation details.
        searchEngine.searchByText(new TextQuery("charging", new TextQuery.Area(getMapViewGeoBox())),
                searchOptions, (searchError, places) -> {
                    if (searchError != null) {
                        Log.d(LOG_TAG, "Search error: " + searchError);
                        return;
                    }
                    for (Place place : places) {
                        Details details = place.getDetails();
                        EVChargingLocation evDetails = details != null ? details.evChargingLocation : null;
                        // evDetails is populated only when the EV license is active.
                    }
                });
    }
}

class EVSearchExample @Throws(InstantiationErrorException::class) constructor() {

    // Provides EVCP 3.0 enrichment; requires an additional EV Charging license beyond Navigate.
    private val searchEngine = SearchEngine()
    private val evSearchEngine = EVSearchEngine()

    init {
        searchEngine.setEVInterface(evSearchEngine)
    }

    // Works standalone for EV-only lookups or alongside SearchEngine to enrich generic results.
    fun searchEVChargingLocationsByPlaceIds(
        placeIds: List<String>,
        searchOptions: SearchOptions
    ) {
        val evOptions = EVSearchOptions().apply {
            additionalFeatures = listOf(
                EVChargingLocationFeature.ENERGY_MIX,
                EVChargingLocationFeature.OPENING_HOURS
            )
        }

        // Direct EVSearchEngine call (can be used without SearchEngine involvement).
        evSearchEngine.setOptions(evOptions)
        evSearchEngine.search(placeIds, { error, locations ->
            if (error != null) {
                Log.d("EVSearchExample", "EV lookup failed: $error")
                return@search
            }
            locations?.forEach { location ->
                val metadata = Metadata().apply {
                    setString("id", location.id)
                    setString("connectorGroups", location.connectorGroups.size.toString())
                }
                // Attach metadata to dedicated EV UI or map markers.
            }
        }, evOptions)

        // Optional: use SearchEngine to enrich general search results with EV metadata.
        searchEngine.searchByText(TextQuery("charging", TextQuery.Area(mapViewGeoBox)),
            searchOptions) { searchError, places ->
            if (searchError != null) {
                Log.d("EVSearchExample", "Search error: $searchError")
                return@searchByText
            }
            places?.forEach { place ->
                val evDetails = place.details?.evChargingLocation
                // evDetails is populated only when the EV license is active.
            }
        }
    }
}

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

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

GeoBox viewportGeoBox = getMapViewGeoBox();
TextQuery.Area queryArea = new TextQuery.Area(viewportGeoBox);
TextQuery query = new TextQuery(queryString, queryArea);

val viewportGeoBox = mapViewGeoBox
val queryArea = TextQuery.Area(viewportGeoBox)
val query = TextQuery(queryString, queryArea)

searchEngine.searchByText(query, searchOptions, querySearchCallback);

...

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

        // If error is null, list is guaranteed to be not empty.
        showDialog("Search", "Results: " + list.size());

        // Add new marker for each search result on map.
        for (Place searchResult : list) {
            // ...
        }
    }
};

searchEngine!!.searchByText(query, searchOptions, querySearchCallback)

...

private val querySearchCallback =
    SearchCallback { searchError, list ->
        if (searchError != null) {
            showDialog("Search", "Error: $searchError")
            return@SearchCallback
        }
        // If error is null, list is guaranteed to be not empty.
        showDialog("Search", "Results: " + list!!.size)

        // Add new marker for each search result on map.
        for (searchResult in list) {
            val metadata = Metadata()
            metadata.setCustomValue("key_search_result", SearchResultMetadata(searchResult))
            // Note: getGeoCoordinates() may return null only for Suggestions.
            addPoiMapMarker(searchResult.geoCoordinates!!, metadata)
        }
    }

// If error is null, list is guaranteed to be not empty.
showDialog("Search", "Results: " + list.size);

// Add new marker for each search result on map.
for (Place searchResult : list) {
    Metadata metadata = new Metadata();
    metadata.setCustomValue("key_search_result", new SearchResultMetadata(searchResult));
    // Note: getGeoCoordinates() may return null only for Suggestions.
    addPoiMapMarker(searchResult.getGeoCoordinates(), metadata);
}

...

// Class to store search results as Metadata.
private static class SearchResultMetadata implements CustomMetadataValue {

    public final Place searchResult;

    public SearchResultMetadata(Place searchResult) {
        this.searchResult = searchResult;
    }

    @NonNull
    @Override
    public String getTag() {
        return "SearchResult Metadata";
    }
}

// If error is null, list is guaranteed to be not empty.
showDialog("Search", "Results: " + list!!.size)

// Add new marker for each search result on map.
for (searchResult in list) {
    val metadata = Metadata()
    metadata.setCustomValue("key_search_result", SearchResultMetadata(searchResult))
    // Note: getGeoCoordinates() may return null only for Suggestions.
    addPoiMapMarker(searchResult.geoCoordinates!!, metadata)
}

...

// Class to store search results as Metadata.
private class SearchResultMetadata(val searchResult: Place) : CustomMetadataValue {
    override fun getTag(): String {
        return "SearchResult Metadata"
    }
}

private void addPoiMapMarker(GeoCoordinates geoCoordinates, Metadata metadata) {
    MapMarker mapMarker = createPoiMapMarker(geoCoordinates);
    mapMarker.setMetadata(metadata);
    mapView.getMapScene().addMapMarker(mapMarker);
    mapMarkerList.add(mapMarker);
}

private MapMarker createPoiMapMarker(GeoCoordinates geoCoordinates) {
    MapImage mapImage = MapImageFactory.fromResource(context.getResources(), R.drawable.poi);
    return new MapMarker(geoCoordinates, mapImage, new Anchor2D(0.5F, 1));
}

private fun addPoiMapMarker(geoCoordinates: GeoCoordinates, metadata: Metadata) {
    val mapMarker = createPoiMapMarker(geoCoordinates)
    mapMarker.metadata = metadata
    mapView.mapScene.addMapMarker(mapMarker)
    mapMarkerList.add(mapMarker)
}

private fun createPoiMapMarker(geoCoordinates: GeoCoordinates): MapMarker {
    val mapImage = MapImageFactory.fromResource(context.resources, R.drawable.poi)
    return MapMarker(geoCoordinates, mapImage, Anchor2D(0.5, 1.0))
}

Metadata metadata = topmostMapMarker.getMetadata();
if (metadata != null) {
    CustomMetadataValue customMetadataValue = metadata.getCustomValue("key_search_result");
    if (customMetadataValue != null) {
        SearchResultMetadata searchResultMetadata = (SearchResultMetadata) customMetadataValue;
        String title = searchResultMetadata.searchResult.getTitle();
        String vicinity = searchResultMetadata.searchResult.getAddress().addressText;
        showDialog("Picked Search Result",title + ". Vicinity: " + vicinity);
        return;
    }
}

val metadata = topmostMapMarker.metadata
if (metadata != null) {
    val customMetadataValue = metadata.getCustomValue("key_search_result")
    if (customMetadataValue != null) {
        val searchResultMetadata = customMetadataValue as SearchResultMetadata
        val title = searchResultMetadata.searchResult.title
        val vicinity = searchResultMetadata.searchResult.address.addressText
        showDialog("Picked Search Result", "$title. Vicinity: $vicinity")
        return@MapPickCallback
    }
}

searchEngine.setCustomOption("discover.show", "tripadvisor");

searchEngine.setCustomOption("discover.show", "tripadvisor")

public void handleWebImages(Place searchResult){
    List<WebImage> webImages = searchResult.getDetails().images;
    for (WebImage webImage: webImages){
        Log.i(LOG_TAG,"WebImage found for place :" +
                searchResult.getTitle().trim() +
                ". Link: " + webImage.source.href);
    }
}

private fun handleWebImages(searchResult: Place) {
    val webImages = searchResult.details.images
    for (webImage in webImages) {
        Log.i(LOG_TAG, "WebImage found for place :" +
                    searchResult.title.trim() +
                    ". Link: " + webImage.source.href)
    }
}

// Set null values to keep the default map orientation.
mapCamera.lookAt(geoBox, new GeoOrientationUpdate(null, null));

Point2D origin = new Point2D(5, 5);
Size2D sizeInPixels = new Size2D(mapView.getWidth() - 10, mapView.getHeight() - 10);
Rectangle2D paddedViewRectangle = new Rectangle2D(origin, sizeInPixels);

try {
    w3wSearchEngine = new W3WSearchEngine();
} catch (InstantiationErrorException e) {
    throw new RuntimeException("Initialization of W3WSearchEngine failed: " + e.error.name());
}

try {
    w3wSearchEngine = W3WSearchEngine()
} catch (e: InstantiationErrorException) {
    throw RuntimeException("Initialization of W3WSearchEngine failed: " + e.error.name)
}

// Sample "dizzy.vanilla.singer" used for demonstration purposes. Replace with user input as needed.
String searchWords = "dizzy.vanilla.singer";

/* Finds the location of a known What3Words term.
* This method searches for the geographic location corresponding to a given three-word address
* (e.g., "dizzy.vanilla.singer").
*/
w3wSearchEngine.search(searchWords, new W3WSearchCallback() {
    @Override
    public void onW3WSearchCompleted(@Nullable W3WSearchError w3WSearchError, @Nullable W3WSquare w3WSquare) {
        handleW3WSearchResult(w3WSearchError, w3WSquare);
    }
});

private void handleW3WSearchResult(@Nullable W3WSearchError w3WSearchError, @Nullable W3WSquare w3WSquare) {
    if (w3WSearchError != null) {
        showDialog("W3Words Search Error", "Error: " + w3WSearchError.toString());
    } else if (w3WSquare != null) {
        // If the search was successful, extract the What3Words.
        String W3Words = w3WSquare.words;

        // Retrieve additional details, such as the coordinates of the square.
        GeoCoordinates southWestCorner = w3WSquare.square.southWestCorner;
        GeoCoordinates northEastCorner = w3WSquare.square.northEastCorner;

        // Check if the details are available and display them in a dialog.
        showDialog("W3Words Details",
                "W3Words: " + W3Words + "\n" +
                        "Language: " + w3WSquare.languageCode + "\n" +
                        "southWestCorner coordinates: " + southWestCorner.latitude + ", " + southWestCorner.longitude + "\n" +
                        "northEastCorner coordinates: " + northEastCorner.latitude + ", " + northEastCorner.longitude);
    }
}

GeoCoordinates geoCoordinates = new GeoCoordinates(52.520798, 13.409408);
// The language code for the desired three-word address.
// ISO 639-1 code "en" specifies that the three-word address will be in English.
String w3wLanguageCode = "en";

/* Resolves geographic coordinates to a What3Words address (three-word format).
* This method uses the What3Words search engine to find a three-word address based
* on the provided coordinates (latitude and longitude).
*/
w3wSearchEngine.search(geoCoordinates, w3wLanguageCode, new W3WSearchCallback() {
    @Override
    public void onW3WSearchCompleted(@Nullable W3WSearchError w3WSearchError, @Nullable W3WSquare w3WSquare) {
        handleW3WSearchResult(w3WSearchError, w3WSquare);
    }
});