---
title: "Mostrar lugares cercanos en un mapa dentro de un flow"
description: "Muestra un mapa con los lugares cercanos a cada usuario, como gimnasios asociados, en un elemento personalizado de una pantalla de flow."
---

> **AI agents**: to search Adapty docs faster and with fewer tokens, install the Adapty skills: `npx adapty skills install --yes`

Sigue esta guía para incluir un mapa interactivo en un flow. El mapa muestra tus lugares, como gimnasios asociados, en un radio de 2 km alrededor del usuario. Tu app renderiza el mapa como una vista nativa en un [elemento personalizado](flow-custom-elements), con MapLibre. Tu app solicita acceso a la ubicación en la pantalla del flow.

## Antes de empezar \{#before-you-start\}

- Actualiza tu app al SDK de Adapty para Android 4.4 o posterior. Las versiones anteriores del SDK muestran el [contenido de respaldo](flow-custom-elements#set-fallback-content) para cada elemento personalizado.
- Configura tu app para [obtener](android-get-pb-paywalls) y [mostrar](android-present-paywalls) flows.
- Para solicitar a los usuarios acceso a la ubicación, muestra los flows en una activity que extienda `ComponentActivity`, como `AppCompatActivity`.
- Añade MapLibre a tu app con Gradle, desde `org.maplibre.gl:android-sdk-opengl`. Con este artefacto, Google Play también ofrece tu app a dispositivos sin Vulkan, que el artefacto predeterminado `android-sdk` requiere.
- Establece `minSdk` en 23 o superior, ya que MapLibre lo requiere.

Para limitar tu app a la ubicación aproximada, añade lo siguiente dentro del elemento `<manifest>` de `AndroidManifest.xml`. Asegúrate de que el elemento `<manifest>` declara `xmlns:tools="http://schemas.android.com/tools"`.

```xml showLineNumbers title="AndroidManifest.xml"
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<!-- removes precise location, which MapLibre declares -->
<uses-permission
    android:name="android.permission.ACCESS_FINE_LOCATION"
    tools:node="remove" />
```

## 1. Añade el elemento personalizado a la pantalla

En el Flow & Paywall Builder, [añade un elemento personalizado](flow-custom-elements#add-and-configure) a una pantalla del flow y configúralo para el mapa:

- **Type**: `map`.
- **ID**: `fitness_centers`.
- **Height**: Mantén la altura **Fixed** por defecto. El mapa ocupa todo el elemento personalizado.

Mantén el elemento personalizado fuera de contenedores que respondan al toque, como un carrusel, para que solo el mapa responda al arrastre.

Dentro del elemento personalizado, añade una [**Imagen**](custom-media#image) con una imagen del mapa. Los usuarios la verán como [respaldo](flow-custom-elements#set-fallback-content) cuando:

- La versión de su app no muestre el mapa.
- Denegaron el acceso a la ubicación antes de que se abriera la pantalla.

Si el usuario aún no ha respondido al mensaje de acceso a la ubicación, tu app lo muestra cuando aparece el mapa. Para explicar a los usuarios por qué tu app necesita su ubicación, añade un elemento de texto encima del elemento personalizado, como "Encuentra centros de fitness cerca de ti."

## 2. Crear la vista del mapa \{#2-create-the-map-view\}

Crea un tipo para tus lugares y un modelo para el acceso a la ubicación:

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

// a place of your app, such as a partner fitness center
data class Place(val name: String, val latitude: Double, val longitude: Double)

private const val PERMISSION = Manifest.permission.ACCESS_COARSE_LOCATION // approximate location

// one location access model for the resolver and the map view
class LocationAccess(context: Context) {
    private val appContext = context.applicationContext
    // checkSelfPermission returns the same value before the first request and after a denial: save the answer
    private val answers = appContext.getSharedPreferences("location_access", Context.MODE_PRIVATE)
    private var isAsking = false
    var isMapOnScreen = false

    val isAllowed: Boolean
        get() = ContextCompat.checkSelfPermission(appContext, PERMISSION) == PackageManager.PERMISSION_GRANTED

    val isDenied: Boolean
        get() = !isAllowed && answers.getBoolean("denied", false)

    // requests location access and saves the answer
    // unregister the returned launcher when the view leaves the screen
    fun requestAccess(activity: ComponentActivity, onAnswer: (Boolean) -> Unit): ActivityResultLauncher<String> {
        val isPromptOpen = isAsking // after a screen rotation, this request receives the answer from the open prompt
        val request = activity.activityResultRegistry.register("location_access", RequestPermission()) { granted ->
            isAsking = false
            answers.edit().putBoolean("denied", !granted).apply()
            onAnswer(granted)
        }
        if (!isPromptOpen) {
            isAsking = true
            request.launch(PERMISSION)
        }
        return request
    }
}

// the activity that shows the flow
tailrec fun Context.findComponentActivity(): ComponentActivity =
    this as? ComponentActivity ?: (this as ContextWrapper).baseContext.findComponentActivity()
```

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

// a place of your app, such as a partner fitness center
public class Place {
    public final String name;
    public final double latitude;
    public final double longitude;

    public Place(String name, double latitude, double longitude) {
        this.name = name;
        this.latitude = latitude;
        this.longitude = longitude;
    }
}

// one location access model for the resolver and the map view
public class LocationAccess {
    private static final String PERMISSION = Manifest.permission.ACCESS_COARSE_LOCATION; // approximate location
    private final Context appContext;
    // checkSelfPermission returns the same value before the first request and after a denial: save the answer
    private final SharedPreferences answers;
    private boolean isAsking;
    public boolean isMapOnScreen;

    public LocationAccess(Context context) {
        appContext = context.getApplicationContext();
        answers = appContext.getSharedPreferences("location_access", Context.MODE_PRIVATE);
    }

    public boolean isAllowed() {
        return ContextCompat.checkSelfPermission(appContext, PERMISSION) == PackageManager.PERMISSION_GRANTED;
    }

    public boolean isDenied() {
        return !isAllowed() && answers.getBoolean("denied", false);
    }

    // requests location access and saves the answer
    // unregister the returned launcher when the view leaves the screen
    public ActivityResultLauncher<String> requestAccess(ComponentActivity activity, ActivityResultCallback<Boolean> onAnswer) {
        boolean isPromptOpen = isAsking; // after a screen rotation, this request receives the answer from the open prompt
        ActivityResultLauncher<String> request = activity.getActivityResultRegistry().register(
                "location_access", new RequestPermission(), granted -> {
                    isAsking = false;
                    answers.edit().putBoolean("denied", !granted).apply();
                    onAnswer.onActivityResult(granted);
                });
        if (!isPromptOpen) {
            isAsking = true;
            request.launch(PERMISSION);
        }
        return request;
    }

    // the activity that shows the flow
    public static ComponentActivity findComponentActivity(Context context) {
        while (!(context instanceof ComponentActivity)) {
            context = ((ContextWrapper) context).getBaseContext();
        }
        return (ComponentActivity) context;
    }
}
```

</TabItem>
</Tabs>

Crea una vista con un mapa. La vista solicita acceso a la ubicación y muestra un marcador por cada uno de tus lugares dentro de 2 km del usuario:

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

// map tiles without an API key
const val MAP_STYLE_URL = "https://tiles.openfreemap.org/styles/liberty"

class NearbyFitnessCentersMap(
    context: Context,
    private val access: LocationAccess,
    private val places: List<Place>,
) : FrameLayout(context), DefaultLifecycleObserver, LocationEngineCallback<LocationEngineResult> {
    private val activity = context.findComponentActivity()
    private val locationEngine = LocationEngineDefault.getDefaultLocationEngine(context)
    private val mapView: MapView
    private var permissionRequest: ActivityResultLauncher<String>? = null

    init {
        MapLibre.getInstance(context)
        mapView = MapView(context)
        mapView.onCreate(null)
        mapView.getMapAsync { map -> map.setStyle(MAP_STYLE_URL) }
        addView(mapView)
    }

    override fun onAttachedToWindow() {
        super.onAttachedToWindow()
        access.isMapOnScreen = true // tells the resolver that the map is on the screen
        activity.lifecycle.addObserver(this)
        when {
            access.isAllowed -> showUser()
            access.isDenied -> showAccessOff()
            else -> permissionRequest = access.requestAccess(activity) { granted ->
                if (granted) showUser() else showAccessOff()
            }
        }
    }

    override fun onDetachedFromWindow() {
        access.isMapOnScreen = false
        permissionRequest?.unregister()
        locationEngine.removeLocationUpdates(this)
        activity.lifecycle.removeObserver(this)
        // the SDK creates a new view each time the custom element appears: release this map
        mapView.onPause()
        mapView.onStop()
        mapView.onDestroy()
        super.onDetachedFromWindow()
    }

    // passes the lifecycle of the activity to the map
    override fun onStart(owner: LifecycleOwner) = mapView.onStart()
    override fun onResume(owner: LifecycleOwner) = mapView.onResume()
    override fun onPause(owner: LifecycleOwner) = mapView.onPause()
    override fun onStop(owner: LifecycleOwner) = mapView.onStop()

    @SuppressLint("MissingPermission") // runs only after the user allows location access
    private fun showUser() = mapView.getMapAsync { map ->
        map.getStyle { style ->
            val options = LocationComponentActivationOptions.builder(context, style).locationEngine(locationEngine)
            map.locationComponent.activateLocationComponent(options.build())
            map.locationComponent.isLocationComponentEnabled = true
            val request = LocationEngineRequest.Builder(1_000).build() // milliseconds between updates
            locationEngine.requestLocationUpdates(request, this, Looper.getMainLooper()) // calls onSuccess
        }
    }

    // the first location of the user
    override fun onSuccess(result: LocationEngineResult) {
        val user = result.lastLocation ?: return
        locationEngine.removeLocationUpdates(this)
        showPlaces(user)
    }

    override fun onFailure(exception: Exception) = Unit

    // a teal circle for each of your places within 2 km of the user
    private fun showPlaces(user: Location) = mapView.getMapAsync { map ->
        val distance = FloatArray(1)
        val pins = places.filter { place ->
            Location.distanceBetween(user.latitude, user.longitude, place.latitude, place.longitude, distance)
            distance[0] <= 2_000 // meters
        }.map { place -> Feature.fromGeometry(Point.fromLngLat(place.longitude, place.latitude)) }
        map.getStyle { style ->
            style.addSource(GeoJsonSource("places", FeatureCollection.fromFeatures(pins)))
            val teal = PropertyFactory.circleColor(Color.rgb(0, 128, 128))
            style.addLayer(CircleLayer("pins", "places").withProperties(teal, PropertyFactory.circleRadius(8f)))
        }
        // zoom in on the area around the user
        map.animateCamera(CameraUpdateFactory.newLatLngZoom(LatLng(user.latitude, user.longitude), 12.0))
    }

    private fun showAccessOff() {
        mapView.visibility = GONE
        addView(TextView(context).apply {
            text = "Location access is off. To see fitness centers near you, allow location access in Settings."
            gravity = Gravity.CENTER
        })
    }
}
```

La vista carga el mapa desde OpenFreeMap, un servicio gratuito que no requiere clave de API y no tiene garantía de disponibilidad. Para cambiar a otra fuente de teselas, modifica la constante `MAP_STYLE_URL`.

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

public class NearbyFitnessCentersMap extends FrameLayout
        implements DefaultLifecycleObserver, LocationEngineCallback<LocationEngineResult> {
    // map tiles without an API key
    public static final String MAP_STYLE_URL = "https://tiles.openfreemap.org/styles/liberty";

    private final LocationAccess access;
    private final List<Place> places;
    private final ComponentActivity activity = LocationAccess.findComponentActivity(getContext());
    private final LocationEngine locationEngine =
            LocationEngineDefault.INSTANCE.getDefaultLocationEngine(getContext());
    private final MapView mapView;
    private ActivityResultLauncher<String> permissionRequest;

    public NearbyFitnessCentersMap(Context context, LocationAccess access, List<Place> places) {
        super(context);
        this.access = access;
        this.places = places;
        MapLibre.getInstance(context);
        mapView = new MapView(context);
        mapView.onCreate(null);
        mapView.getMapAsync(map -> map.setStyle(MAP_STYLE_URL));
        addView(mapView);
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        access.isMapOnScreen = true; // tells the resolver that the map is on the screen
        activity.getLifecycle().addObserver(this);
        if (access.isAllowed()) showUser();
        else if (access.isDenied()) showAccessOff();
        else permissionRequest = access.requestAccess(activity, granted -> {
            if (granted) showUser(); else showAccessOff();
        });
    }

    @Override
    protected void onDetachedFromWindow() {
        access.isMapOnScreen = false;
        if (permissionRequest != null) permissionRequest.unregister();
        locationEngine.removeLocationUpdates(this);
        activity.getLifecycle().removeObserver(this);
        // the SDK creates a new view each time the custom element appears: release this map
        mapView.onPause();
        mapView.onStop();
        mapView.onDestroy();
        super.onDetachedFromWindow();
    }

    // passes the lifecycle of the activity to the map
    @Override public void onStart(LifecycleOwner owner) { mapView.onStart(); }
    @Override public void onResume(LifecycleOwner owner) { mapView.onResume(); }
    @Override public void onPause(LifecycleOwner owner) { mapView.onPause(); }
    @Override public void onStop(LifecycleOwner owner) { mapView.onStop(); }

    @SuppressLint("MissingPermission") // runs only after the user allows location access
    private void showUser() {
        mapView.getMapAsync(map -> map.getStyle(style -> {
            map.getLocationComponent().activateLocationComponent(
                    LocationComponentActivationOptions.builder(getContext(), style).locationEngine(locationEngine).build());
            map.getLocationComponent().setLocationComponentEnabled(true);
            LocationEngineRequest request = new LocationEngineRequest.Builder(1000).build(); // milliseconds between updates
            locationEngine.requestLocationUpdates(request, this, Looper.getMainLooper()); // calls onSuccess
        }));
    }

    // the first location of the user
    @Override
    public void onSuccess(LocationEngineResult result) {
        Location user = result.getLastLocation();
        if (user == null) return;
        locationEngine.removeLocationUpdates(this);
        showPlaces(user);
    }

    @Override public void onFailure(Exception exception) {}

    // a teal circle for each of your places within 2 km of the user
    private void showPlaces(Location user) {
        List<Feature> pins = new ArrayList<>();
        float[] distance = new float[1];
        for (Place place : places) {
            Location.distanceBetween(user.getLatitude(), user.getLongitude(), place.latitude, place.longitude, distance);
            if (distance[0] > 2000) continue; // meters
            pins.add(Feature.fromGeometry(Point.fromLngLat(place.longitude, place.latitude)));
        }
        mapView.getMapAsync(map -> map.getStyle(style -> {
            style.addSource(new GeoJsonSource("places", FeatureCollection.fromFeatures(pins)));
            style.addLayer(new CircleLayer("pins", "places").withProperties(
                    PropertyFactory.circleColor(Color.rgb(0, 128, 128)), PropertyFactory.circleRadius(8f)));
            // zoom in on the area around the user
            map.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(user.getLatitude(), user.getLongitude()), 12));
        }));
    }

    private void showAccessOff() {
        mapView.setVisibility(GONE);
        TextView message = new TextView(getContext());
        message.setText("Location access is off. To see fitness centers near you, allow location access in Settings.");
        message.setGravity(Gravity.CENTER);
        addView(message);
    }
}
```

La vista carga el mapa desde OpenFreeMap, un servicio gratuito que no requiere clave de API y no ofrece garantías de disponibilidad. Para cambiar la fuente de teselas, modifica la constante `MAP_STYLE_URL`.

</TabItem>
</Tabs>

Si el usuario deniega el acceso a la ubicación en la pantalla, la vista reemplaza el mapa con un mensaje sobre cómo permitir el acceso en Configuración.

## 3. Vincula el mapa al elemento personalizado \{#match-the-map-to-the-custom-element\}

En tu [resolver global](android-flow-custom-elements#display-views-in-every-flow), añade las propiedades del modelo `LocationAccess` y tus lugares. Luego devuelve la vista del mapa para el Type `map` y el ID `fitness_centers`. Las líneas resaltadas muestran qué añadir o cambiar. Si tu app aún no tiene un [resolver](android-flow-custom-elements#write-a-resolver-to-match-custom-elements-and-views) global, copia el código completo:

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin" {7,9,13-24}

class CustomElementsResolver(
    context: Context,
    private val places: List<Place>, // your app's places, such as partner fitness centers
) : AdaptyCustomElementsResolver {
    private val locationAccess = LocationAccess(context)

    override fun resolve(type: String, id: String): AdaptyCustomElementContent? =
        when (type) {
            "map" -> when (id) {
                "fitness_centers" ->
                    if (locationAccess.isDenied && !locationAccess.isMapOnScreen) {
                        null // access denied before the screen opened: show the fallback
                    } else {
                        AdaptyCustomElementContent.view(
                            factory = { context, _ -> NearbyFitnessCentersMap(context, locationAccess, places) },
                        )
                    }
                // the other maps of your resolver
                else -> null
            }
            // the other Types of your resolver
            else -> null
        }
}
```

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java" {7-8,10-12,17-28}

public class CustomElementsResolver implements AdaptyCustomElementsResolver {
    private final LocationAccess locationAccess;
    private final List<Place> places; // your app's places, such as partner fitness centers

    public CustomElementsResolver(Context context, List<Place> places) {
        this.locationAccess = new LocationAccess(context);
        this.places = places;
    }

    @Override
    public AdaptyCustomElementContent resolve(String type, String id) {
        if (type.equals("map")) {
            if (id.equals("fitness_centers")) {
                if (locationAccess.isDenied() && !locationAccess.isMapOnScreen) {
                    return null; // access denied before the screen opened: show the fallback
                }
                return AdaptyCustomElementContent.view(
                        (context, elementContext) -> new NearbyFitnessCentersMap(context, locationAccess, places)
                );
            }
            // the other maps of your resolver
            return null;
        }
        // the other Types of your resolver
        return null;
    }
}
```

</TabItem>
</Tabs>

El SDK llama al resolver cuando se abre la pantalla, y de nuevo cada vez que redibuja el elemento personalizado mientras la pantalla está abierta. El acceso a la ubicación determina lo que devuelve el resolver en cada llamada:

- **Sin respuesta aún**: La vista del mapa, para que la vista pueda solicitar acceso.
- **Permitido**: La vista del mapa, que muestra tus lugares cercanos al usuario.
- **Denegado antes de que se abriera la pantalla**: Ninguna vista, por lo que los usuarios ven el paywall de respaldo en lugar del mensaje sobre la Configuración.
- **Denegado en la pantalla**: La vista del mapa, porque la vista establece `isMapOnScreen` mientras está en pantalla. Si el resolver no devolviera ninguna vista aquí, el SDK reemplazaría el mensaje sobre la Configuración con el paywall de respaldo en la siguiente llamada.

Crea el resolver con tus elementos y configúralo como el resolver global de la aplicación. Llama a `AdaptyUI.setCustomElementsResolver` una sola vez, por ejemplo al iniciar la app:

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

class App : Application() {
    // your app's places, such as partner fitness centers
    val places = listOf(
        Place("Central Fitness", latitude = 52.5219, longitude = 13.4132),
        Place("Riverside Gym", latitude = 52.5163, longitude = 13.3777),
    )

    // keep this instance: a resolver for one flow can reuse it
    // lazy: the context isn't attached yet while App is constructed
    val customElementsResolver by lazy { CustomElementsResolver(this, places) }

    override fun onCreate() {
        super.onCreate()
        AdaptyUI.setCustomElementsResolver(customElementsResolver)
    }
}
```

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

public class App extends Application {
    // your app's places, such as partner fitness centers
    private final List<Place> places = Arrays.asList(
            new Place("Central Fitness", 52.5219, 13.4132),
            new Place("Riverside Gym", 52.5163, 13.3777)
    );
    // keep this instance: a resolver for one flow can reuse it
    private CustomElementsResolver customElementsResolver;

    @Override
    public void onCreate() {
        super.onCreate();
        customElementsResolver = new CustomElementsResolver(this, places);
        AdaptyUI.setCustomElementsResolver(customElementsResolver);
    }

    public CustomElementsResolver getCustomElementsResolver() {
        return customElementsResolver;
    }
}
```

</TabItem>
</Tabs>

## 4. Prueba en un dispositivo \{#4-test-on-a-device\}

El Flow & Paywall Builder no puede ejecutar el código de tu app, por lo que el canvas solo muestra el respaldo. Para previsualizar el mapa:

1. [Publica el flow](builder-save-publish). Para ver la última versión publicada en lugar de una en caché, registra el dispositivo como [dispositivo de prueba](test-devices).
2. Para ver un marcador en el mapa, añade un lugar dentro de un radio de 2 km desde tu ubicación a tu lista de lugares.
3. Compila tu app con el resolver incluido. Abre la pantalla y permite el acceso a la ubicación. Comprueba que el mapa muestra tu ubicación y un marcador para el lugar que añadiste.

Para probar el paywall de respaldo, abre la app **Settings**, desactiva el acceso a la ubicación para tu app. Abre la pantalla y, si aparece la solicitud, deniega el acceso a la ubicación. La vista del mapa mostrará el mensaje sobre Settings. Abre la pantalla de nuevo y verifica que aparezca el paywall de respaldo.

Para saber por qué aparece el paywall de respaldo en lugar del mapa, sigue las instrucciones de la sección [Pruebas en un dispositivo](android-flow-custom-elements#test-on-a-device) de la guía de Android.