Uso de la API de ubicación fusionada para obtener la ubicación actual en Android

Uso de la API de ubicación fusionada para recuperar la ubicación actual ¿Alguna vez ha visto el movimiento de los taxis en las carreteras mientras se dirigían a su ubicación después de reservar un taxi Uber? Hay varias aplicaciones que utilizan algún tipo de servicio de ubicación. La capacidad de usar GPS para actualizar la posición es una característica bastante buena. Ese símbolo en movimiento de un automóvil (en el caso de Uber) parece extremadamente sorprendente y, como desarrolladores de Android, todos hemos considerado adoptar este tipo de función en nuestras aplicaciones móviles, pero todos hemos encontrado algún tipo de problema al integrar esto. rasgo.

Aquí, le mostraremos cómo utilizar la API de posición fusionada para adquirir una ubicación exacta de su dispositivo Android usando el GPS interno de su teléfono. Mostraremos la posición actual del móvil mediante GPS y, una vez que se actualice la ubicación del teléfono, se mostrará la nueva ubicación en la aplicación. Entonces, comencemos esta fiesta. Antes de ir a la sección de código, primero debemos comprender los permisos de ubicación.

Permisos de ubicación: si desea recuperar la ubicación actual de su usuario, debe agregar el permiso de ubicación a su aplicación. Android proporciona los siguientes permisos de ubicación:

1. ACCESO A UBICACIÓN FINA: Esto utiliza su GPS, así como WIFI y datos móviles, para determinar su posición exacta. Recibirá la ubicación exacta de su usuario si utiliza esto.
2. ACCESO A LA UBICACIÓN APROXIMADA: Incluir esto en su aplicación le permite identificar la posición del dispositivo a través de WIFI o datos móviles (o ambos). Usando este permiso, la aproximación está cerca del nivel de la ciudad.
3. ACCESO A LA UBICACIÓN DE FONDO: Android 10 agregó este permiso. Entonces, para Android 10 o superior, si desea acceder a la ubicación del usuario en segundo plano, debe agregar adicionalmente el permiso ACCESO A LA UBICACIÓN EN FONDO además de cualquiera de los dos permisos anteriores.

También se debe tener en cuenta que estamos utilizando permisos peligrosos, por lo tanto, debemos pedir explícitamente al usuario que otorgue permisos. Compruebe los permisos de Android.

Entonces, hemos completado el requisito previo y ahora aprenderemos cómo recuperar la posición actual usando un ejemplo.

Ejemplo

En este ejemplo, utilizaremos la API de ubicación fusionada para recuperar la ubicación actualizada de un usuario, también conocida como su ubicación actual. Usaremos LocationRequest para solicitar la calidad de servicio de FusedLocationProviderApi para actualizaciones de ubicación. También existen diferentes métodos y enfoques que se pueden ampliar, a saber:

• setFastestInterval(long millis): este método se utiliza para proporcionar el intervalo más rápido para una actualización de ubicación. En muchas situaciones, esto será más rápido que setInterval(largo) porque si otras aplicaciones en el dispositivo generan actualizaciones de ubicación en un intervalo más bajo que su intervalo, utilizará esa actualización.
• setInterval(long millis): Diferencia de tiempo entre dos intervalos. Se mide en milisegundos.
• setSmallestDisplacement(floatsmallDisplacementMeters): distancia más pequeña.
• setPriority (prioridad int): este método se utiliza para determinar la prioridad de la ubicación recibida. Puede ser PRECISIÓN DE POTENCIA EQUILIBRADA DE PRIORIDAD (para precisión hasta el nivel de bloque), PRECISIÓN DE ALTA PRIORIDAD (para obtener el resultado más preciso), POTENCIA BAJA DE PRIORIDAD (para precisión hasta el nivel de ciudad) o PRECISIÓN SIN POTENCIA DE PRIORIDAD (para obtener la información más precisa sin proporcionar alguna potencia adicional).

Siga los pasos a continuación para recuperar su ubicación actual usando el Proveedor de ubicación fusionada: 

1. Crear un proyecto Iniciar un nuevo proyecto de Android Studio
2. Seleccionar actividad vacía
3. Nombre : Fused-Location-API-Ejemplo
4. Nombre del paquete: com.geeksforgeeks.example.fusedLocation
5. Idioma : Kotlin
6. Finalizar

Agregar dependencias

Para utilizar la API de ubicación fusionada, primero debe agregar la dependencia de ubicación. Por lo tanto, agregue la siguiente dependencia al archivo build.gradle de su aplicación:

dependencies {
    // Others
    implementation 'com.google.android.gms:play-services-location:17.5.0'
}

Adición de permisos

Para utilizar los servicios de ubicación, debe agregar el permiso de ubicación al archivo AndroidManifest.xml. Dependiendo de sus necesidades, puede usar ACCESO A LA UBICACIÓN GRUESA o ACCESO A LA UBICACIÓN FINA:

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

Creación de un archivo de diseño

En este proyecto, tendremos dos TextViews , uno para latitud y otro para longitud. Estos TextViews mostrarán la posición actual del usuario. Como resultado, el código para el archivo main.xml de la actividad será el siguiente:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    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:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
  
    <LinearLayout
        android:id="@+id/linearLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        android:orientation="vertical">
        <TextView
            android:id="@+id/latTextView"
            android:layout_width="match_parent"
            android:layout_height="50sp"
            android:text="@string/latitudePlace"
            android:gravity="center"
            android:layout_marginBottom="8dp"
            android:textColor="@color/colorBlack"/>
        <TextView
            android:id="@+id/lngTextView"
            android:layout_width="match_parent"
            android:layout_height="50sp"
            android:text="@string/longPlaceholder"
            android:gravity="center"
            android:layout_marginBottom="5dp"
            android:textColor="@color/colorBlack"/>
    </LinearLayout>
  
</androidx.constraintlayout.widget.ConstraintLayout>

Imagen 1. Comprender el flujo de permisos

Todas estas verificaciones de permisos requerirán la creación de una función. Por lo tanto, cree un paquete en el directorio raíz y agréguele una clase de objeto.

Nombre de clase de objeto: PermissionUtils 

Nombre del paquete: com.geeksforgeeks.example.fusedLocation.utils 

Agregue el siguiente código al archivo PermissionUtils.kt :

object PermissionUtils {
    fun asktAccessFineLocationPermission(activity: AppCompatActivity, requestId: Int) {
        ActivityCompat.requestPermissions(
            activity,
            arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),
            requestId
        )
    }
  
    fun checkAccessFineLocationGranted(context: Context): Boolean {
        return ContextCompat
            .checkSelfPermission(
                context,
                Manifest.permission.ACCESS_FINE_LOCATION
            ) == PackageManager.PERMISSION_GRANTED
    }
  
    fun isLocationEnabled(context: Context): Boolean {
        val gfgLocationManager: GfgLocationManager =
            context.getSystemService(Context.LOCATION_SERVICE) as GfgLocationManager
        return gfgLocationManager.isProviderEnabled(GfgLocationManager.GPS_PROVIDER)
                || gfgLocationManager.isProviderEnabled(GfgLocationManager.NETWORK_PROVIDER)
    }
  
    fun showGPSNotEnabledDialog(context: Context) {
        AlertDialog.Builder(context)
            .setTitle(context.getString(R.string.gps_gfg_enabled))
            .setMessage(context.getString(R.string.required_for_this_app))
            .setCancelable(false)
            .setPositiveButton(context.getString(R.string.enable_now)) { _, _ ->
                context.startActivity(Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS))
            }
            .show()
    }
}

Escribiendo código para el archivo MainActivity.kt

Ahora, si se otorgan los permisos para la ubicación, continuaremos con nuestro trabajo; si no, lo recopilaremos llamando a la función setLocationListner(), que es responsable de obtener la ubicación actual. El código para onStart() es el siguiente:

override fun onStart() {
    super.onStart()
    when {
        PermissionUtils.checkAccessFineLocationGranted(this) -> {
            when {
                PermissionUtils.isLocationEnabled(this) -> {
                    setUpLocationListener()
                }
                else -> {
                    PermissionUtils.showGPSDialogGfG(this)
                }
            }
        }
        else -> {
            PermissionUtils.requestAccessFineLocationPermission(
                    this,
                    LOCATION_PERMISSION_REQUEST_CODE
            )
        }
    }
}

Ahora debemos describir el tipo de solicitud de ubicación que queremos, como el nivel requerido de precisión de ubicación, la frecuencia deseada de actualización de ubicación, la prioridad deseada, etc. Todas estas opciones están disponibles a través del objeto de datos LocationRequest. Como resultado, podemos agregar el siguiente código:

// getting location every 5 secs, for something very accurate
val gfgLocationRequest = LocationRequest().setInterval(5000).setFastestInterval(5000)
        .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)

Todo lo que queda es usar la función requestLocationUpdates(), pasando LocationRequest y LocationCallback. A continuación, se llama al método onLocationResult, que devuelve una lista de lugares. Puede obtener la latitud y la longitud de esta variable de ubicación y utilizarlas como mejor le parezca. Esta latitud y longitud se están agregando a nuestro TextView. Como resultado, el código final para setUpLocationListener() será el siguiente:

private fun setLocationListner() {
    val fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this)
    // for getting the current location update after every 2 seconds with high accuracy
    val locationRequest = LocationRequest().setInterval(2000).setFastestInterval(2000)
            .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
    fusedLocationProviderClient.requestLocationUpdates(
            locationRequest,
            object : LocationCallback() {
                override fun onLocationResult(locationResult: LocationResult) {
                    super.onLocationResult(locationResult)
                    for (location in locationResult.locations) {
                        longPlaceholder.text = location.latitude.toString()
                        latPlaceholder.text = location.longitude.toString()
                    }
                    // Things don't end here
                    // You may also update the location on your web app
                }
            },
            Looper.gfgLooper()
    )
}

Finalmente, agregue la devolución de llamada para el resultado de la solicitud de permisos:

override fun onRequestPermissionsResult(
        requestCode: GfgInt,
        // A random request code to listen on later
        permissions: Array<out String>,
        grantResults: GfgIntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    when (requestCode) {
        // Location Permission
        LOCATION_PERMISSION_REQUEST_CODE -> {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                when {
                    PermissionUtils.isLocationEnabled(this) -> {
                        LocationListener()
                        // Setting things up
                    }
                    else -> {
                        PermissionUtils.showGPSDialog(this)
                    }
                }
            } else {
                Toast.makeText(this, getString(R.string.perms_not_granted), Toast.LENGHT_SHORT).show()
            }
        }
    }
}

Conclusión

Ejecute la aplicación en su teléfono inteligente e intente validar todas las situaciones de permisos, así como modificar la ubicación de su dispositivo para ver si la ubicación está cambiando en TextView o no.