Identificación una ubicación en un rango de coordenadas google map

Introducción:

Este artículo explora cómo aprovechar la potencia de Google Maps en aplicaciones Android para identificar si una ubicación específica se encuentra dentro de un polígono predefinido. Implementaremos un ejemplo práctico que te permitirá comprender cómo utilizar esta funcionalidad en tu propio proyecto.

Contenido del Artículo:

Introducción a la Identificación de Coordenadas y Polígonos: Un resumen de por qué esta funcionalidad es valiosa y cuándo puede ser aplicada en aplicaciones móviles.
Creación de una Aplicación en Android con Google Maps: Cómo configurar una aplicación Android y su integración con la API de Google Maps.
Definición del Polígono: Cómo especificar y delinear las coordenadas de un polígono en el mapa.
Solicitud de Permisos de Ubicación: Cómo garantizar que la aplicación tenga permiso para acceder a la ubicación del dispositivo.
Verificación de Ubicación en el Polígono: Implementación de la lógica para determinar si la ubicación GPS se encuentra dentro del polígono definido.
Visualización en el Mapa: Cómo mostrar las coordenadas del polígono y las coordenadas GPS en el mapa.

LIBRERIAS

1. com.google.android.gms:play-services-location:18.0.0: Esta librería proporciona acceso a la ubicación del dispositivo, seguimiento en tiempo real, detección de actividad y más, lo que es crucial para aplicaciones que dependen de datos de ubicación.

2. com.google.android.gms:play-services-maps:18.0.0: Para mostrar mapas interactivos de Google en la aplicación, esta librería es indispensable. Ofrece funcionalidades como zoom, marcadores y rutas.

3. com.google.maps.android:android-maps-utils:2.2.0: Esta librería ofrece utilidades adicionales para trabajar con mapas en Android. Incluye funciones para verificar si una ubicación está dentro de un polígono, calcular áreas de polígonos y más.

DISEÑO

El XML proporcionado es la estructura de diseño de una interfaz de usuario para una aplicación Android que utiliza la API de Google Maps para mostrar un mapa y brindar información sobre la identificación de coordenadas y polígonos en un área determinada. Aquí se detalla su estructura:

RelativeLayout: Es el contenedor principal que alinea y organiza los elementos de la interfaz.
Fragment de Google Maps: Se utiliza para mostrar el mapa de Google en la aplicación. El fragmento tiene un ancho y alto correspondiente al tamaño completo de la pantalla.
LinearLayout (bottomLayout): Es un contenedor secundario que se encuentra en la parte inferior de la pantalla para mostrar información relacionada con el mapa y las coordenadas.
TextViews: Se utilizan para mostrar texto en la interfaz de usuario:
- poligonoTituloTextView: Muestra el título “Polígono” en negrita.
- poligonoInfoTextView: Muestra información relacionada con las coordenadas del polígono.
- gpsTituloTextView: Muestra el título “GPS” en negrita.
- gpsInfoTextView: Muestra información relacionada con las coordenadas del GPS.
- resultadoTituloTextView: Muestra el título “Resultado” en negrita.
- resultadoTextView: Muestra el resultado de la verificación de coordenadas y el estado de la ubicación en relación con el polígono. Se muestra en rojo (#FF0000) para resaltar la importancia del mensaje.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/mapLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <fragment
        android:id="@+id/map"
        android:name="com.google.android.gms.maps.SupportMapFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <LinearLayout
        android:id="@+id/bottomLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:background="#CCFFFFFF"
        android:orientation="vertical">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">

            <LinearLayout
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:orientation="vertical">

                <TextView
                    android:id="@+id/poligonoTituloTextView"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center"
                    android:padding="5dp"
                    android:text="Polígono: "
                    android:textSize="26sp"
                    android:textStyle="bold" />

                <TextView
                    android:id="@+id/poligonoInfoTextView"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center"
                    android:padding="25dp"
                    android:text="Coordenadas del Polígono" />
            </LinearLayout>

            <LinearLayout
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:orientation="vertical">

                <TextView
                    android:id="@+id/gpsTituloTextView"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center"
                    android:padding="5dp"
                    android:text="GPS: "
                    android:textSize="26sp"
                    android:textStyle="bold" />

                <TextView
                    android:id="@+id/gpsInfoTextView"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center"
                    android:padding="25dp"
                    android:text="Coordenadas del GPS" />

            </LinearLayout>
        </LinearLayout>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">
            <TextView
                android:id="@+id/resultadoTituloTextView"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:gravity="center_horizontal"
                android:padding="5dp"
                android:text="Resultado: "
                android:textSize="26sp"
                android:textStyle="bold" />

            <TextView
                android:id="@+id/resultadoTextView"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_gravity="center"
                android:padding="5dp"
                android:text="Coordenadas del GPS"
                android:textColor="#FF0000"
                android:textStyle="bold"
                android:textSize="20sp"/>

        </LinearLayout>
    </LinearLayout>
</RelativeLayout>

Permisos y Clave de API de Google Maps en Android

En el fragmento de código del archivo AndroidManifest.xml, se establecen los permisos y se integra la clave de API de Google Maps. Aquí se explica su significado y propósito:

<uses-permission android:name="android.permission.INTERNET" />: Este permiso permite que la aplicación acceda a Internet. Es esencial para que la aplicación pueda cargar mapas y servicios de ubicación en línea, ya que necesitará conectarse a los servidores de Google Maps.
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> y <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />: Estos permisos permiten que la aplicación acceda a la ubicación del dispositivo. ACCESS_FINE_LOCATION proporciona una ubicación más precisa y ACCESS_COARSE_LOCATION una ubicación aproximada. En este caso, la aplicación parece requerir permisos de ubicación para funcionar correctamente.
<meta-data android:name="com.google.android.geo.API_KEY" android:value="TU_CLAVE_DE_API">: Aquí se debe insertar la clave de API de Google Maps. Esta clave es única para cada proyecto y se utiliza para identificar y autorizar el acceso a los servicios de Google Maps. Sin esta clave, la integración de mapas no funcionará correctamente.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.identificarrangocoordenada">

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.IdentificarRangoCoordenada">
        <activity android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- Agrega la clave de API de Google Maps aquí -->
        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="AQUI DEBES AGREGAR TU API_KEY" />

        <meta-data
            android:name="com.google.android.gms.version"
            android:value="@integer/google_play_services_version" />
    </application>

</manifest>

Descripción del Código – Identificación de Ubicación en un Polígono con Ancho en Android

Este código representa una aplicación de Android que utiliza Google Maps y servicios de ubicación para verificar si una ubicación GPS se encuentra dentro de un polígono predefinido, teniendo en cuenta un ancho configurable.

Resumen de lo que hace el código:

Configuración inicial: El código comienza configurando las bibliotecas necesarias y declarando las variables requeridas. También se definen permisos de ubicación en el archivo AndroidManifest.xml.
Definición de un polígono: Se definen las coordenadas del polígono que se utilizarán para determinar si la ubicación GPS está dentro. El polígono consta de cuatro puntos en este caso.
Dibujo del polígono en el mapa: Se agrega el polígono al mapa con un ancho de línea y un color específicos.
Solicitud de permisos de ubicación: El código verifica si se han otorgado los permisos de ubicación necesarios para la aplicación. Si los permisos no se han otorgado, solicita la autorización al usuario.
Obtención de la ubicación del GPS: Utilizando FusedLocationProviderClient, se obtiene la ubicación GPS actual del dispositivo. Luego, se verifica si esta ubicación se encuentra dentro del polígono definido, teniendo en cuenta un ancho configurable.
Actualización de la interfaz de usuario: Se actualizan varios TextView en la interfaz de usuario con la información relevante. Se muestra si la ubicación está dentro o fuera del polígono. También se agrega un marcador en el mapa para representar la ubicación GPS.
Configuración del mapa: El código establece el nivel de zoom del mapa y lo centra en la ubicación GPS.

Notas Adicionales:

El valor anchoPoligono se puede ajustar según las necesidades para controlar cuán cerca de los límites del polígono se considerará la ubicación GPS.
La interfaz de usuario se compone de TextViews que muestran información relevante, como las coordenadas del polígono, las coordenadas del GPS y el resultado de la verificación.
Se utilizan bibliotecas de Google Maps y PolyUtil para llevar a cabo la verificación y mostrar el mapa en la interfaz de usuario.

En resumen, este código crea una aplicación de Android que permite a los usuarios verificar si su ubicación GPS está dentro de un polígono predefinido, lo que puede ser útil en diversas aplicaciones, como geofencing y seguimiento de ubicación.

package com.example.identificarrangocoordenada

import android.Manifest
import android.annotation.SuppressLint
import android.content.pm.PackageManager
import android.graphics.Color
import android.os.Bundle
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationServices
import com.google.android.gms.maps.*
import com.google.android.gms.maps.model.*
import com.google.maps.android.PolyUtil

class MainActivity : AppCompatActivity(), OnMapReadyCallback {
    private lateinit var mMap: GoogleMap
    private lateinit var fusedLocationClient: FusedLocationProviderClient
    private val LOCATION_PERMISSION_REQUEST_CODE = 1

    // Declaración de TextViews
    private lateinit var poligonoTextView: TextView
    private lateinit var gpsTextView: TextView
    private lateinit var resultadoText: TextView

    override fun onMapReady(googleMap: GoogleMap) {
        mMap = googleMap

        // Define las coordenadas del polígono
        val coordenadasPoligono = listOf(
            LatLng(-6.7600, -79.8655),
            LatLng(-6.7600, -79.8657),
            LatLng(-6.7603, -79.8657),
            LatLng(-6.7603, -79.8655)
        )

        // Dibuja el polígono en el mapa
        val polygonOptions = PolygonOptions()
        polygonOptions.addAll(coordenadasPoligono)
        polygonOptions.strokeWidth(300f)
        polygonOptions.strokeColor(Color.GREEN)
        mMap.addPolygon(polygonOptions)

        // Solicita permisos de ubicación
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
            fusedLocationClient.lastLocation.addOnSuccessListener(this) { location ->
                location?.let {
                    val ubicacion = LatLng(it.latitude, it.longitude)

                    // Verifica si la ubicación está dentro del polígono considerando el ancho
                    val anchoPoligono = 100.0 // Puedes ajustar el valor según tus necesidades
                    val estaDentro = PolyUtil.isLocationOnPath(ubicacion, coordenadasPoligono, true, anchoPoligono)

                    if (estaDentro) {
                        resultadoText.text = "La ubicación está dentro del polígono"
                    } else {
                        resultadoText.text = "La ubicación está fuera del polígono"
                    }

                    // Llena los TextViews con las coordenadas
                    poligonoTextView.text = "Coordenadas del Polígono: " + obtenerCoordenadas(coordenadasPoligono)
                    gpsTextView.text = "Coordenadas del GPS: ${ubicacion.latitude}, ${ubicacion.longitude}"

                    // Añade un marcador para las coordenadas del GPS
                    mMap.addMarker(MarkerOptions().position(ubicacion).title("Ubicación GPS"))

                    // Configura el nivel de zoom y centra el mapa en la ubicación
                    val zoomLevel = 15.0f
                    val cameraPosition = CameraPosition.Builder()
                        .target(ubicacion)
                        .zoom(zoomLevel)
                        .build()

                    mMap.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPosition))
                }
            }
        } else {
            // Solicita permisos de ubicación
            ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION), LOCATION_PERMISSION_REQUEST_CODE)
        }
    }

    @SuppressLint("MissingInflatedId")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Obtén el mapa de la vista
        val mapFragment = supportFragmentManager.findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)

        // Inicializa los TextViews
        poligonoTextView = findViewById(R.id.poligonoInfoTextView)
        gpsTextView = findViewById(R.id.gpsInfoTextView)
        resultadoText = findViewById(R.id.resultadoTextView)
    }

    // Función para obtener las coordenadas del polígono
    private fun obtenerCoordenadas(coordenadas: List<LatLng>): String {
        val coordenadasStr = StringBuilder()
        for (coordenada in coordenadas) {
            coordenadasStr.append("${coordenada.latitude}, ${coordenada.longitude}\n")
        }
        return coordenadasStr.toString()
    }
}

ANDROFAST

Hola soy Alex Céspedes fundador de ANDROFAST, programo algunas cosas por diversión, me gusta aprender cosas nuevas y estoy pendiente de todo lo que tenga que ver con tecnología. Este blog lo cree para todas las personas que tengan dificultades en la programación, para ser sincero nunca fui bueno y reprobé algunos cursos de programación, pero mis ganas de aprender pudieron más. SI YO PUEDO TU PUEDES ANIMO!

Deja una respuesta Cancelar la respuesta